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                 //mt:zstd
2089                 Blk MapBlk
2090         }))(obj)).Blkpos {
2091                 {
2092                         x := ((*(*(struct {
2093                                 Blkpos [3]int16
2094                                 //mt:zstd
2095                                 Blk MapBlk
2096                         }))(obj)).Blkpos)[local62]
2097                         write16(w, uint16(x))
2098                 }
2099         }
2100         {
2101                 w, err := zstd.NewWriter(w)
2102                 chk(err)
2103                 if err := pcall(func() {
2104                         ((*(*(struct {
2105                                 Blkpos [3]int16
2106                                 //mt:zstd
2107                                 Blk MapBlk
2108                         }))(obj)).Blk).serialize(w)
2109                 }); err != nil {
2110                         if err == io.EOF {
2111                                 chk(io.EOF)
2112                         }
2113                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlk", err))
2114                 }
2115                 chk(w.Close())
2116         }
2117 }
2118
2119 func (obj *ToCltBlkData) deserialize(r io.Reader) {
2120         for local63 := range (*(*(struct {
2121                 Blkpos [3]int16
2122                 //mt:zstd
2123                 Blk MapBlk
2124         }))(obj)).Blkpos {
2125                 {
2126                         p := &((*(*(struct {
2127                                 Blkpos [3]int16
2128                                 //mt:zstd
2129                                 Blk MapBlk
2130                         }))(obj)).Blkpos)[local63]
2131                         *p = int16(read16(r))
2132                 }
2133         }
2134         {
2135                 r, err := zstd.NewReader(byteReader{r})
2136                 chk(err)
2137                 if err := pcall(func() {
2138                         ((*(*(struct {
2139                                 Blkpos [3]int16
2140                                 //mt:zstd
2141                                 Blk MapBlk
2142                         }))(obj)).Blk).deserialize(r)
2143                 }); err != nil {
2144                         if err == io.EOF {
2145                                 chk(io.EOF)
2146                         }
2147                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlk", err))
2148                 }
2149                 r.Close()
2150         }
2151 }
2152
2153 func (obj *ToCltAddNode) serialize(w io.Writer) {
2154         for local64 := range (*(*(struct {
2155                 Pos [3]int16
2156                 Node
2157                 KeepMeta bool
2158         }))(obj)).Pos {
2159                 {
2160                         x := ((*(*(struct {
2161                                 Pos [3]int16
2162                                 Node
2163                                 KeepMeta bool
2164                         }))(obj)).Pos)[local64]
2165                         write16(w, uint16(x))
2166                 }
2167         }
2168         if err := pcall(func() {
2169                 ((*(*(struct {
2170                         Pos [3]int16
2171                         Node
2172                         KeepMeta bool
2173                 }))(obj)).Node).serialize(w)
2174         }); err != nil {
2175                 if err == io.EOF {
2176                         chk(io.EOF)
2177                 }
2178                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Node", err))
2179         }
2180         {
2181                 x := (*(*(struct {
2182                         Pos [3]int16
2183                         Node
2184                         KeepMeta bool
2185                 }))(obj)).KeepMeta
2186                 if x {
2187                         write8(w, 1)
2188                 } else {
2189                         write8(w, 0)
2190                 }
2191         }
2192 }
2193
2194 func (obj *ToCltAddNode) deserialize(r io.Reader) {
2195         for local65 := range (*(*(struct {
2196                 Pos [3]int16
2197                 Node
2198                 KeepMeta bool
2199         }))(obj)).Pos {
2200                 {
2201                         p := &((*(*(struct {
2202                                 Pos [3]int16
2203                                 Node
2204                                 KeepMeta bool
2205                         }))(obj)).Pos)[local65]
2206                         *p = int16(read16(r))
2207                 }
2208         }
2209         if err := pcall(func() {
2210                 ((*(*(struct {
2211                         Pos [3]int16
2212                         Node
2213                         KeepMeta bool
2214                 }))(obj)).Node).deserialize(r)
2215         }); err != nil {
2216                 if err == io.EOF {
2217                         chk(io.EOF)
2218                 }
2219                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Node", err))
2220         }
2221         {
2222                 p := &(*(*(struct {
2223                         Pos [3]int16
2224                         Node
2225                         KeepMeta bool
2226                 }))(obj)).KeepMeta
2227                 switch n := read8(r); n {
2228                 case 0:
2229                         *p = false
2230                 case 1:
2231                         *p = true
2232                 default:
2233                         chk(fmt.Errorf("invalid bool: %d", n))
2234                 }
2235         }
2236 }
2237
2238 func (obj *ToCltRemoveNode) serialize(w io.Writer) {
2239         for local66 := range (*(*(struct {
2240                 Pos [3]int16
2241         }))(obj)).Pos {
2242                 {
2243                         x := ((*(*(struct {
2244                                 Pos [3]int16
2245                         }))(obj)).Pos)[local66]
2246                         write16(w, uint16(x))
2247                 }
2248         }
2249 }
2250
2251 func (obj *ToCltRemoveNode) deserialize(r io.Reader) {
2252         for local67 := range (*(*(struct {
2253                 Pos [3]int16
2254         }))(obj)).Pos {
2255                 {
2256                         p := &((*(*(struct {
2257                                 Pos [3]int16
2258                         }))(obj)).Pos)[local67]
2259                         *p = int16(read16(r))
2260                 }
2261         }
2262 }
2263
2264 func (obj *ToCltInv) serialize(w io.Writer) {
2265         {
2266                 _, err := w.Write(([]byte((*(*(struct {
2267                         //mt:raw
2268                         Inv string
2269                 }))(obj)).Inv))[:])
2270                 chk(err)
2271         }
2272 }
2273
2274 func (obj *ToCltInv) deserialize(r io.Reader) {
2275         var local68 []uint8
2276         {
2277                 var err error
2278                 (local68), err = io.ReadAll(r)
2279                 chk(err)
2280         }
2281         ((*(*(struct {
2282                 //mt:raw
2283                 Inv string
2284         }))(obj)).Inv) = string(local68)
2285 }
2286
2287 func (obj *ToCltTimeOfDay) serialize(w io.Writer) {
2288         {
2289                 x := (*(*(struct {
2290                         Time  uint16  // %24000
2291                         Speed float32 // Speed times faster than real time
2292                 }))(obj)).Time
2293                 write16(w, uint16(x))
2294         }
2295         {
2296                 x := (*(*(struct {
2297                         Time  uint16  // %24000
2298                         Speed float32 // Speed times faster than real time
2299                 }))(obj)).Speed
2300                 write32(w, math.Float32bits(x))
2301         }
2302 }
2303
2304 func (obj *ToCltTimeOfDay) deserialize(r io.Reader) {
2305         {
2306                 p := &(*(*(struct {
2307                         Time  uint16  // %24000
2308                         Speed float32 // Speed times faster than real time
2309                 }))(obj)).Time
2310                 *p = read16(r)
2311         }
2312         {
2313                 p := &(*(*(struct {
2314                         Time  uint16  // %24000
2315                         Speed float32 // Speed times faster than real time
2316                 }))(obj)).Speed
2317                 *p = math.Float32frombits(read32(r))
2318         }
2319 }
2320
2321 func (obj *ToCltCSMRestrictionFlags) serialize(w io.Writer) {
2322         if err := pcall(func() {
2323                 ((*(*(struct {
2324                         Flags CSMRestrictionFlags
2325
2326                         // MapRange is the maximum distance from the player CSMs can read the map
2327                         // if Flags&LimitMapRange != 0.
2328                         MapRange uint32
2329                 }))(obj)).Flags).serialize(w)
2330         }); err != nil {
2331                 if err == io.EOF {
2332                         chk(io.EOF)
2333                 }
2334                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CSMRestrictionFlags", err))
2335         }
2336         {
2337                 x := (*(*(struct {
2338                         Flags CSMRestrictionFlags
2339
2340                         // MapRange is the maximum distance from the player CSMs can read the map
2341                         // if Flags&LimitMapRange != 0.
2342                         MapRange uint32
2343                 }))(obj)).MapRange
2344                 write32(w, uint32(x))
2345         }
2346 }
2347
2348 func (obj *ToCltCSMRestrictionFlags) deserialize(r io.Reader) {
2349         if err := pcall(func() {
2350                 ((*(*(struct {
2351                         Flags CSMRestrictionFlags
2352
2353                         // MapRange is the maximum distance from the player CSMs can read the map
2354                         // if Flags&LimitMapRange != 0.
2355                         MapRange uint32
2356                 }))(obj)).Flags).deserialize(r)
2357         }); err != nil {
2358                 if err == io.EOF {
2359                         chk(io.EOF)
2360                 }
2361                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CSMRestrictionFlags", err))
2362         }
2363         {
2364                 p := &(*(*(struct {
2365                         Flags CSMRestrictionFlags
2366
2367                         // MapRange is the maximum distance from the player CSMs can read the map
2368                         // if Flags&LimitMapRange != 0.
2369                         MapRange uint32
2370                 }))(obj)).MapRange
2371                 *p = read32(r)
2372         }
2373 }
2374
2375 func (obj *ToCltAddPlayerVel) serialize(w io.Writer) {
2376         if err := pcall(func() {
2377                 ((*(*(struct {
2378                         Vel Vec
2379                 }))(obj)).Vel).serialize(w)
2380         }); err != nil {
2381                 if err == io.EOF {
2382                         chk(io.EOF)
2383                 }
2384                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
2385         }
2386 }
2387
2388 func (obj *ToCltAddPlayerVel) deserialize(r io.Reader) {
2389         if err := pcall(func() {
2390                 ((*(*(struct {
2391                         Vel Vec
2392                 }))(obj)).Vel).deserialize(r)
2393         }); err != nil {
2394                 if err == io.EOF {
2395                         chk(io.EOF)
2396                 }
2397                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
2398         }
2399 }
2400
2401 func (obj *ToCltMediaPush) serialize(w io.Writer) {
2402         if len(([]byte((*(*(struct {
2403                 RawHash       string
2404                 Filename      string
2405                 CallbackToken uint32
2406                 ShouldCache   bool
2407         }))(obj)).RawHash))) > math.MaxUint16 {
2408                 chk(ErrTooLong)
2409         }
2410         {
2411                 x := uint16(len(([]byte((*(*(struct {
2412                         RawHash       string
2413                         Filename      string
2414                         CallbackToken uint32
2415                         ShouldCache   bool
2416                 }))(obj)).RawHash))))
2417                 write16(w, uint16(x))
2418         }
2419         {
2420                 _, err := w.Write(([]byte((*(*(struct {
2421                         RawHash       string
2422                         Filename      string
2423                         CallbackToken uint32
2424                         ShouldCache   bool
2425                 }))(obj)).RawHash))[:])
2426                 chk(err)
2427         }
2428         if len(([]byte((*(*(struct {
2429                 RawHash       string
2430                 Filename      string
2431                 CallbackToken uint32
2432                 ShouldCache   bool
2433         }))(obj)).Filename))) > math.MaxUint16 {
2434                 chk(ErrTooLong)
2435         }
2436         {
2437                 x := uint16(len(([]byte((*(*(struct {
2438                         RawHash       string
2439                         Filename      string
2440                         CallbackToken uint32
2441                         ShouldCache   bool
2442                 }))(obj)).Filename))))
2443                 write16(w, uint16(x))
2444         }
2445         {
2446                 _, err := w.Write(([]byte((*(*(struct {
2447                         RawHash       string
2448                         Filename      string
2449                         CallbackToken uint32
2450                         ShouldCache   bool
2451                 }))(obj)).Filename))[:])
2452                 chk(err)
2453         }
2454         {
2455                 x := (*(*(struct {
2456                         RawHash       string
2457                         Filename      string
2458                         CallbackToken uint32
2459                         ShouldCache   bool
2460                 }))(obj)).CallbackToken
2461                 write32(w, uint32(x))
2462         }
2463         {
2464                 x := (*(*(struct {
2465                         RawHash       string
2466                         Filename      string
2467                         CallbackToken uint32
2468                         ShouldCache   bool
2469                 }))(obj)).ShouldCache
2470                 if x {
2471                         write8(w, 1)
2472                 } else {
2473                         write8(w, 0)
2474                 }
2475         }
2476 }
2477
2478 func (obj *ToCltMediaPush) deserialize(r io.Reader) {
2479         var local69 []uint8
2480         var local70 uint16
2481         {
2482                 p := &local70
2483                 *p = read16(r)
2484         }
2485         (local69) = make([]uint8, local70)
2486         {
2487                 _, err := io.ReadFull(r, (local69)[:])
2488                 chk(err)
2489         }
2490         ((*(*(struct {
2491                 RawHash       string
2492                 Filename      string
2493                 CallbackToken uint32
2494                 ShouldCache   bool
2495         }))(obj)).RawHash) = string(local69)
2496         var local71 []uint8
2497         var local72 uint16
2498         {
2499                 p := &local72
2500                 *p = read16(r)
2501         }
2502         (local71) = make([]uint8, local72)
2503         {
2504                 _, err := io.ReadFull(r, (local71)[:])
2505                 chk(err)
2506         }
2507         ((*(*(struct {
2508                 RawHash       string
2509                 Filename      string
2510                 CallbackToken uint32
2511                 ShouldCache   bool
2512         }))(obj)).Filename) = string(local71)
2513         {
2514                 p := &(*(*(struct {
2515                         RawHash       string
2516                         Filename      string
2517                         CallbackToken uint32
2518                         ShouldCache   bool
2519                 }))(obj)).CallbackToken
2520                 *p = read32(r)
2521         }
2522         {
2523                 p := &(*(*(struct {
2524                         RawHash       string
2525                         Filename      string
2526                         CallbackToken uint32
2527                         ShouldCache   bool
2528                 }))(obj)).ShouldCache
2529                 switch n := read8(r); n {
2530                 case 0:
2531                         *p = false
2532                 case 1:
2533                         *p = true
2534                 default:
2535                         chk(fmt.Errorf("invalid bool: %d", n))
2536                 }
2537         }
2538 }
2539
2540 func (obj *ToCltChatMsg) serialize(w io.Writer) {
2541         {
2542                 local73 := uint8(1)
2543                 {
2544                         x := local73
2545                         write8(w, uint8(x))
2546                 }
2547         }
2548         if err := pcall(func() {
2549                 ((*(*(struct {
2550                         Type ChatMsgType
2551
2552                         //mt:utf16
2553                         Sender, Text string
2554
2555                         Timestamp int64 // Unix time.
2556                 }))(obj)).Type).serialize(w)
2557         }); err != nil {
2558                 if err == io.EOF {
2559                         chk(io.EOF)
2560                 }
2561                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ChatMsgType", err))
2562         }
2563         local74 := utf16.Encode([]rune((*(*(struct {
2564                 Type ChatMsgType
2565
2566                 //mt:utf16
2567                 Sender, Text string
2568
2569                 Timestamp int64 // Unix time.
2570         }))(obj)).Sender))
2571         if len((local74)) > math.MaxUint16 {
2572                 chk(ErrTooLong)
2573         }
2574         {
2575                 x := uint16(len((local74)))
2576                 write16(w, uint16(x))
2577         }
2578         for local75 := range local74 {
2579                 {
2580                         x := (local74)[local75]
2581                         write16(w, uint16(x))
2582                 }
2583         }
2584         local76 := utf16.Encode([]rune((*(*(struct {
2585                 Type ChatMsgType
2586
2587                 //mt:utf16
2588                 Sender, Text string
2589
2590                 Timestamp int64 // Unix time.
2591         }))(obj)).Text))
2592         if len((local76)) > math.MaxUint16 {
2593                 chk(ErrTooLong)
2594         }
2595         {
2596                 x := uint16(len((local76)))
2597                 write16(w, uint16(x))
2598         }
2599         for local77 := range local76 {
2600                 {
2601                         x := (local76)[local77]
2602                         write16(w, uint16(x))
2603                 }
2604         }
2605         {
2606                 x := (*(*(struct {
2607                         Type ChatMsgType
2608
2609                         //mt:utf16
2610                         Sender, Text string
2611
2612                         Timestamp int64 // Unix time.
2613                 }))(obj)).Timestamp
2614                 write64(w, uint64(x))
2615         }
2616 }
2617
2618 func (obj *ToCltChatMsg) deserialize(r io.Reader) {
2619         {
2620                 var local78 uint8
2621                 local79 := uint8(1)
2622                 {
2623                         p := &local78
2624                         *p = read8(r)
2625                 }
2626                 if local78 != local79 {
2627                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local78))
2628                 }
2629         }
2630         if err := pcall(func() {
2631                 ((*(*(struct {
2632                         Type ChatMsgType
2633
2634                         //mt:utf16
2635                         Sender, Text string
2636
2637                         Timestamp int64 // Unix time.
2638                 }))(obj)).Type).deserialize(r)
2639         }); err != nil {
2640                 if err == io.EOF {
2641                         chk(io.EOF)
2642                 }
2643                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ChatMsgType", err))
2644         }
2645         var local80 []uint16
2646         var local81 uint16
2647         {
2648                 p := &local81
2649                 *p = read16(r)
2650         }
2651         (local80) = make([]uint16, local81)
2652         for local82 := range local80 {
2653                 {
2654                         p := &(local80)[local82]
2655                         *p = read16(r)
2656                 }
2657         }
2658         (*(*(struct {
2659                 Type ChatMsgType
2660
2661                 //mt:utf16
2662                 Sender, Text string
2663
2664                 Timestamp int64 // Unix time.
2665         }))(obj)).Sender = string(utf16.Decode(local80))
2666         var local83 []uint16
2667         var local84 uint16
2668         {
2669                 p := &local84
2670                 *p = read16(r)
2671         }
2672         (local83) = make([]uint16, local84)
2673         for local85 := range local83 {
2674                 {
2675                         p := &(local83)[local85]
2676                         *p = read16(r)
2677                 }
2678         }
2679         (*(*(struct {
2680                 Type ChatMsgType
2681
2682                 //mt:utf16
2683                 Sender, Text string
2684
2685                 Timestamp int64 // Unix time.
2686         }))(obj)).Text = string(utf16.Decode(local83))
2687         {
2688                 p := &(*(*(struct {
2689                         Type ChatMsgType
2690
2691                         //mt:utf16
2692                         Sender, Text string
2693
2694                         Timestamp int64 // Unix time.
2695                 }))(obj)).Timestamp
2696                 *p = int64(read64(r))
2697         }
2698 }
2699
2700 func (obj *ToCltAORmAdd) serialize(w io.Writer) {
2701         if len(((*(*(struct {
2702                 Remove []AOID
2703                 Add    []AOAdd
2704         }))(obj)).Remove)) > math.MaxUint16 {
2705                 chk(ErrTooLong)
2706         }
2707         {
2708                 x := uint16(len(((*(*(struct {
2709                         Remove []AOID
2710                         Add    []AOAdd
2711                 }))(obj)).Remove)))
2712                 write16(w, uint16(x))
2713         }
2714         for local86 := range (*(*(struct {
2715                 Remove []AOID
2716                 Add    []AOAdd
2717         }))(obj)).Remove {
2718                 if err := pcall(func() {
2719                         (((*(*(struct {
2720                                 Remove []AOID
2721                                 Add    []AOAdd
2722                         }))(obj)).Remove)[local86]).serialize(w)
2723                 }); err != nil {
2724                         if err == io.EOF {
2725                                 chk(io.EOF)
2726                         }
2727                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
2728                 }
2729         }
2730         if len(((*(*(struct {
2731                 Remove []AOID
2732                 Add    []AOAdd
2733         }))(obj)).Add)) > math.MaxUint16 {
2734                 chk(ErrTooLong)
2735         }
2736         {
2737                 x := uint16(len(((*(*(struct {
2738                         Remove []AOID
2739                         Add    []AOAdd
2740                 }))(obj)).Add)))
2741                 write16(w, uint16(x))
2742         }
2743         for local87 := range (*(*(struct {
2744                 Remove []AOID
2745                 Add    []AOAdd
2746         }))(obj)).Add {
2747                 if err := pcall(func() {
2748                         (((*(*(struct {
2749                                 Remove []AOID
2750                                 Add    []AOAdd
2751                         }))(obj)).Add)[local87]).serialize(w)
2752                 }); err != nil {
2753                         if err == io.EOF {
2754                                 chk(io.EOF)
2755                         }
2756                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAdd", err))
2757                 }
2758         }
2759 }
2760
2761 func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
2762         var local88 uint16
2763         {
2764                 p := &local88
2765                 *p = read16(r)
2766         }
2767         ((*(*(struct {
2768                 Remove []AOID
2769                 Add    []AOAdd
2770         }))(obj)).Remove) = make([]AOID, local88)
2771         for local89 := range (*(*(struct {
2772                 Remove []AOID
2773                 Add    []AOAdd
2774         }))(obj)).Remove {
2775                 if err := pcall(func() {
2776                         (((*(*(struct {
2777                                 Remove []AOID
2778                                 Add    []AOAdd
2779                         }))(obj)).Remove)[local89]).deserialize(r)
2780                 }); err != nil {
2781                         if err == io.EOF {
2782                                 chk(io.EOF)
2783                         }
2784                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
2785                 }
2786         }
2787         var local90 uint16
2788         {
2789                 p := &local90
2790                 *p = read16(r)
2791         }
2792         ((*(*(struct {
2793                 Remove []AOID
2794                 Add    []AOAdd
2795         }))(obj)).Add) = make([]AOAdd, local90)
2796         for local91 := range (*(*(struct {
2797                 Remove []AOID
2798                 Add    []AOAdd
2799         }))(obj)).Add {
2800                 if err := pcall(func() {
2801                         (((*(*(struct {
2802                                 Remove []AOID
2803                                 Add    []AOAdd
2804                         }))(obj)).Add)[local91]).deserialize(r)
2805                 }); err != nil {
2806                         if err == io.EOF {
2807                                 chk(io.EOF)
2808                         }
2809                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAdd", err))
2810                 }
2811         }
2812 }
2813
2814 func (obj *ToCltAOMsgs) serialize(w io.Writer) {
2815         for local92 := range (*(*(struct {
2816                 //mt:raw
2817                 Msgs []IDAOMsg
2818         }))(obj)).Msgs {
2819                 if err := pcall(func() {
2820                         (((*(*(struct {
2821                                 //mt:raw
2822                                 Msgs []IDAOMsg
2823                         }))(obj)).Msgs)[local92]).serialize(w)
2824                 }); err != nil {
2825                         if err == io.EOF {
2826                                 chk(io.EOF)
2827                         }
2828                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.IDAOMsg", err))
2829                 }
2830         }
2831 }
2832
2833 func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
2834         for {
2835                 var local93 IDAOMsg
2836                 err := pcall(func() {
2837                         if err := pcall(func() {
2838                                 (local93).deserialize(r)
2839                         }); err != nil {
2840                                 if err == io.EOF {
2841                                         chk(io.EOF)
2842                                 }
2843                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.IDAOMsg", err))
2844                         }
2845                 })
2846                 if err == io.EOF {
2847                         break
2848                 }
2849                 ((*(*(struct {
2850                         //mt:raw
2851                         Msgs []IDAOMsg
2852                 }))(obj)).Msgs) = append(((*(*(struct {
2853                         //mt:raw
2854                         Msgs []IDAOMsg
2855                 }))(obj)).Msgs), local93)
2856                 chk(err)
2857         }
2858 }
2859
2860 func (obj *ToCltHP) serialize(w io.Writer) {
2861         {
2862                 x := (*(*(struct {
2863                         HP uint16
2864                 }))(obj)).HP
2865                 write16(w, uint16(x))
2866         }
2867 }
2868
2869 func (obj *ToCltHP) deserialize(r io.Reader) {
2870         {
2871                 p := &(*(*(struct {
2872                         HP uint16
2873                 }))(obj)).HP
2874                 *p = read16(r)
2875         }
2876 }
2877
2878 func (obj *ToCltMovePlayer) serialize(w io.Writer) {
2879         if err := pcall(func() {
2880                 ((*(*(struct {
2881                         Pos
2882                         Pitch, Yaw float32
2883                 }))(obj)).Pos).serialize(w)
2884         }); err != nil {
2885                 if err == io.EOF {
2886                         chk(io.EOF)
2887                 }
2888                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
2889         }
2890         {
2891                 x := (*(*(struct {
2892                         Pos
2893                         Pitch, Yaw float32
2894                 }))(obj)).Pitch
2895                 write32(w, math.Float32bits(x))
2896         }
2897         {
2898                 x := (*(*(struct {
2899                         Pos
2900                         Pitch, Yaw float32
2901                 }))(obj)).Yaw
2902                 write32(w, math.Float32bits(x))
2903         }
2904 }
2905
2906 func (obj *ToCltMovePlayer) deserialize(r io.Reader) {
2907         if err := pcall(func() {
2908                 ((*(*(struct {
2909                         Pos
2910                         Pitch, Yaw float32
2911                 }))(obj)).Pos).deserialize(r)
2912         }); err != nil {
2913                 if err == io.EOF {
2914                         chk(io.EOF)
2915                 }
2916                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
2917         }
2918         {
2919                 p := &(*(*(struct {
2920                         Pos
2921                         Pitch, Yaw float32
2922                 }))(obj)).Pitch
2923                 *p = math.Float32frombits(read32(r))
2924         }
2925         {
2926                 p := &(*(*(struct {
2927                         Pos
2928                         Pitch, Yaw float32
2929                 }))(obj)).Yaw
2930                 *p = math.Float32frombits(read32(r))
2931         }
2932 }
2933
2934 func (obj *ToCltLegacyKick) serialize(w io.Writer) {
2935         local94 := utf16.Encode([]rune((*(*(struct {
2936                 //mt:utf16
2937                 Reason string
2938         }))(obj)).Reason))
2939         if len((local94)) > math.MaxUint16 {
2940                 chk(ErrTooLong)
2941         }
2942         {
2943                 x := uint16(len((local94)))
2944                 write16(w, uint16(x))
2945         }
2946         for local95 := range local94 {
2947                 {
2948                         x := (local94)[local95]
2949                         write16(w, uint16(x))
2950                 }
2951         }
2952 }
2953
2954 func (obj *ToCltLegacyKick) deserialize(r io.Reader) {
2955         var local96 []uint16
2956         var local97 uint16
2957         {
2958                 p := &local97
2959                 *p = read16(r)
2960         }
2961         (local96) = make([]uint16, local97)
2962         for local98 := range local96 {
2963                 {
2964                         p := &(local96)[local98]
2965                         *p = read16(r)
2966                 }
2967         }
2968         (*(*(struct {
2969                 //mt:utf16
2970                 Reason string
2971         }))(obj)).Reason = string(utf16.Decode(local96))
2972 }
2973
2974 func (obj *ToCltFOV) serialize(w io.Writer) {
2975         {
2976                 x := (*(*(struct {
2977                         FOV            float32
2978                         Multiplier     bool
2979                         TransitionTime float32
2980                 }))(obj)).FOV
2981                 write32(w, math.Float32bits(x))
2982         }
2983         {
2984                 x := (*(*(struct {
2985                         FOV            float32
2986                         Multiplier     bool
2987                         TransitionTime float32
2988                 }))(obj)).Multiplier
2989                 if x {
2990                         write8(w, 1)
2991                 } else {
2992                         write8(w, 0)
2993                 }
2994         }
2995         {
2996                 x := (*(*(struct {
2997                         FOV            float32
2998                         Multiplier     bool
2999                         TransitionTime float32
3000                 }))(obj)).TransitionTime
3001                 write32(w, math.Float32bits(x))
3002         }
3003 }
3004
3005 func (obj *ToCltFOV) deserialize(r io.Reader) {
3006         {
3007                 p := &(*(*(struct {
3008                         FOV            float32
3009                         Multiplier     bool
3010                         TransitionTime float32
3011                 }))(obj)).FOV
3012                 *p = math.Float32frombits(read32(r))
3013         }
3014         {
3015                 p := &(*(*(struct {
3016                         FOV            float32
3017                         Multiplier     bool
3018                         TransitionTime float32
3019                 }))(obj)).Multiplier
3020                 switch n := read8(r); n {
3021                 case 0:
3022                         *p = false
3023                 case 1:
3024                         *p = true
3025                 default:
3026                         chk(fmt.Errorf("invalid bool: %d", n))
3027                 }
3028         }
3029         {
3030                 p := &(*(*(struct {
3031                         FOV            float32
3032                         Multiplier     bool
3033                         TransitionTime float32
3034                 }))(obj)).TransitionTime
3035                 *p = math.Float32frombits(read32(r))
3036         }
3037 }
3038
3039 func (obj *ToCltDeathScreen) serialize(w io.Writer) {
3040         {
3041                 x := (*(*(struct {
3042                         PointCam bool
3043                         PointAt  Pos
3044                 }))(obj)).PointCam
3045                 if x {
3046                         write8(w, 1)
3047                 } else {
3048                         write8(w, 0)
3049                 }
3050         }
3051         if err := pcall(func() {
3052                 ((*(*(struct {
3053                         PointCam bool
3054                         PointAt  Pos
3055                 }))(obj)).PointAt).serialize(w)
3056         }); err != nil {
3057                 if err == io.EOF {
3058                         chk(io.EOF)
3059                 }
3060                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
3061         }
3062 }
3063
3064 func (obj *ToCltDeathScreen) deserialize(r io.Reader) {
3065         {
3066                 p := &(*(*(struct {
3067                         PointCam bool
3068                         PointAt  Pos
3069                 }))(obj)).PointCam
3070                 switch n := read8(r); n {
3071                 case 0:
3072                         *p = false
3073                 case 1:
3074                         *p = true
3075                 default:
3076                         chk(fmt.Errorf("invalid bool: %d", n))
3077                 }
3078         }
3079         if err := pcall(func() {
3080                 ((*(*(struct {
3081                         PointCam bool
3082                         PointAt  Pos
3083                 }))(obj)).PointAt).deserialize(r)
3084         }); err != nil {
3085                 if err == io.EOF {
3086                         chk(io.EOF)
3087                 }
3088                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
3089         }
3090 }
3091
3092 func (obj *ToCltMedia) serialize(w io.Writer) {
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)).N
3107                 write16(w, uint16(x))
3108         }
3109         {
3110                 x := (*(*(struct {
3111                         // N is the total number of ToCltMedia packets.
3112                         // I is the index of this packet.
3113                         N, I uint16
3114
3115                         //mt:len32
3116                         Files []struct {
3117                                 Name string
3118
3119                                 //mt:len32
3120                                 Data []byte
3121                         }
3122                 }))(obj)).I
3123                 write16(w, uint16(x))
3124         }
3125         if 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)) > math.MaxUint32 {
3138                 chk(ErrTooLong)
3139         }
3140         {
3141                 x := uint32(len(((*(*(struct {
3142                         // N is the total number of ToCltMedia packets.
3143                         // I is the index of this packet.
3144                         N, I uint16
3145
3146                         //mt:len32
3147                         Files []struct {
3148                                 Name string
3149
3150                                 //mt:len32
3151                                 Data []byte
3152                         }
3153                 }))(obj)).Files)))
3154                 write32(w, uint32(x))
3155         }
3156         for local99 := range (*(*(struct {
3157                 // N is the total number of ToCltMedia packets.
3158                 // I is the index of this packet.
3159                 N, I uint16
3160
3161                 //mt:len32
3162                 Files []struct {
3163                         Name string
3164
3165                         //mt:len32
3166                         Data []byte
3167                 }
3168         }))(obj)).Files {
3169                 if 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))) > math.MaxUint16 {
3182                         chk(ErrTooLong)
3183                 }
3184                 {
3185                         x := uint16(len(([]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                         write16(w, uint16(x))
3199                 }
3200                 {
3201                         _, err := w.Write(([]byte((((*(*(struct {
3202                                 // N is the total number of ToCltMedia packets.
3203                                 // I is the index of this packet.
3204                                 N, I uint16
3205
3206                                 //mt:len32
3207                                 Files []struct {
3208                                         Name string
3209
3210                                         //mt:len32
3211                                         Data []byte
3212                                 }
3213                         }))(obj)).Files)[local99]).Name))[:])
3214                         chk(err)
3215                 }
3216                 if 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)) > math.MaxUint32 {
3229                         chk(ErrTooLong)
3230                 }
3231                 {
3232                         x := uint32(len(((((*(*(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                         write32(w, uint32(x))
3246                 }
3247                 {
3248                         _, err := w.Write(((((*(*(struct {
3249                                 // N is the total number of ToCltMedia packets.
3250                                 // I is the index of this packet.
3251                                 N, I uint16
3252
3253                                 //mt:len32
3254                                 Files []struct {
3255                                         Name string
3256
3257                                         //mt:len32
3258                                         Data []byte
3259                                 }
3260                         }))(obj)).Files)[local99]).Data)[:])
3261                         chk(err)
3262                 }
3263         }
3264 }
3265
3266 func (obj *ToCltMedia) deserialize(r io.Reader) {
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)).N
3281                 *p = read16(r)
3282         }
3283         {
3284                 p := &(*(*(struct {
3285                         // N is the total number of ToCltMedia packets.
3286                         // I is the index of this packet.
3287                         N, I uint16
3288
3289                         //mt:len32
3290                         Files []struct {
3291                                 Name string
3292
3293                                 //mt:len32
3294                                 Data []byte
3295                         }
3296                 }))(obj)).I
3297                 *p = read16(r)
3298         }
3299         var local100 uint32
3300         {
3301                 p := &local100
3302                 *p = read32(r)
3303         }
3304         ((*(*(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) = make([]struct {
3317                 Name string
3318                 Data []byte
3319         }, local100)
3320         for local101 := range (*(*(struct {
3321                 // N is the total number of ToCltMedia packets.
3322                 // I is the index of this packet.
3323                 N, I uint16
3324
3325                 //mt:len32
3326                 Files []struct {
3327                         Name string
3328
3329                         //mt:len32
3330                         Data []byte
3331                 }
3332         }))(obj)).Files {
3333                 var local102 []uint8
3334                 var local103 uint16
3335                 {
3336                         p := &local103
3337                         *p = read16(r)
3338                 }
3339                 (local102) = make([]uint8, local103)
3340                 {
3341                         _, err := io.ReadFull(r, (local102)[:])
3342                         chk(err)
3343                 }
3344                 ((((*(*(struct {
3345                         // N is the total number of ToCltMedia packets.
3346                         // I is the index of this packet.
3347                         N, I uint16
3348
3349                         //mt:len32
3350                         Files []struct {
3351                                 Name string
3352
3353                                 //mt:len32
3354                                 Data []byte
3355                         }
3356                 }))(obj)).Files)[local101]).Name) = string(local102)
3357                 var local104 uint32
3358                 {
3359                         p := &local104
3360                         *p = read32(r)
3361                 }
3362                 ((((*(*(struct {
3363                         // N is the total number of ToCltMedia packets.
3364                         // I is the index of this packet.
3365                         N, I uint16
3366
3367                         //mt:len32
3368                         Files []struct {
3369                                 Name string
3370
3371                                 //mt:len32
3372                                 Data []byte
3373                         }
3374                 }))(obj)).Files)[local101]).Data) = make([]byte, local104)
3375                 {
3376                         _, err := io.ReadFull(r, ((((*(*(struct {
3377                                 // N is the total number of ToCltMedia packets.
3378                                 // I is the index of this packet.
3379                                 N, I uint16
3380
3381                                 //mt:len32
3382                                 Files []struct {
3383                                         Name string
3384
3385                                         //mt:len32
3386                                         Data []byte
3387                                 }
3388                         }))(obj)).Files)[local101]).Data)[:])
3389                         chk(err)
3390                 }
3391         }
3392 }
3393
3394 func (obj *ToCltNodeDefs) serialize(w io.Writer) {
3395         {
3396                 ow := w
3397                 w := new(bytes.Buffer)
3398                 {
3399                         w := zlib.NewWriter(w)
3400                         {
3401                                 local105 := uint8(1)
3402                                 {
3403                                         x := local105
3404                                         write8(w, uint8(x))
3405                                 }
3406                         }
3407                         {
3408                                 x := (*(*(struct {
3409
3410                                         // See (de)serialize.fmt.
3411                                         Defs []NodeDef
3412                                 }))(obj)).Defs
3413                                 { // For ToCltNodeDefs.Defs.
3414                                         if len(x) > math.MaxUint16 {
3415                                                 chk(ErrTooLong)
3416                                         }
3417                                         write16(w, uint16(len(x)))
3418                                         var b bytes.Buffer
3419                                         for i := range x {
3420                                                 x[i].serialize(&b)
3421                                         }
3422                                         if b.Len() > math.MaxUint32 {
3423                                                 chk(ErrTooLong)
3424                                         }
3425                                         write32(w, uint32(b.Len()))
3426                                         _, err := b.WriteTo(w)
3427                                         chk(err)
3428                                 }
3429                         }
3430                         chk(w.Close())
3431                 }
3432                 {
3433                         buf := w
3434                         w := ow
3435                         if len((buf.Bytes())) > math.MaxUint32 {
3436                                 chk(ErrTooLong)
3437                         }
3438                         {
3439                                 x := uint32(len((buf.Bytes())))
3440                                 write32(w, uint32(x))
3441                         }
3442                         {
3443                                 _, err := w.Write((buf.Bytes())[:])
3444                                 chk(err)
3445                         }
3446                 }
3447         }
3448 }
3449
3450 func (obj *ToCltNodeDefs) deserialize(r io.Reader) {
3451         {
3452                 var n uint32
3453                 {
3454                         p := &n
3455                         *p = read32(r)
3456                 }
3457                 r := &io.LimitedReader{R: r, N: int64(n)}
3458                 {
3459                         r, err := zlib.NewReader(byteReader{r})
3460                         chk(err)
3461                         {
3462                                 var local106 uint8
3463                                 local107 := uint8(1)
3464                                 {
3465                                         p := &local106
3466                                         *p = read8(r)
3467                                 }
3468                                 if local106 != local107 {
3469                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local106))
3470                                 }
3471                         }
3472                         {
3473                                 p := &(*(*(struct {
3474
3475                                         // See (de)serialize.fmt.
3476                                         Defs []NodeDef
3477                                 }))(obj)).Defs
3478                                 { // For ToCltNodeDefs.Defs.
3479                                         *p = make([]NodeDef, read16(r))
3480                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3481                                         for i := range *p {
3482                                                 (*p)[i].deserialize(r)
3483                                         }
3484                                         if r.N > 0 {
3485                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3486                                         }
3487                                 }
3488                         }
3489                         chk(r.Close())
3490                 }
3491                 if r.N > 0 {
3492                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3493                 }
3494         }
3495 }
3496
3497 func (obj *ToCltAnnounceMedia) serialize(w io.Writer) {
3498         if len(((*(*(struct {
3499                 Files []struct {
3500                         Name       string
3501                         Base64SHA1 string
3502                 }
3503                 URL string
3504         }))(obj)).Files)) > math.MaxUint16 {
3505                 chk(ErrTooLong)
3506         }
3507         {
3508                 x := uint16(len(((*(*(struct {
3509                         Files []struct {
3510                                 Name       string
3511                                 Base64SHA1 string
3512                         }
3513                         URL string
3514                 }))(obj)).Files)))
3515                 write16(w, uint16(x))
3516         }
3517         for local108 := range (*(*(struct {
3518                 Files []struct {
3519                         Name       string
3520                         Base64SHA1 string
3521                 }
3522                 URL string
3523         }))(obj)).Files {
3524                 if len(([]byte((((*(*(struct {
3525                         Files []struct {
3526                                 Name       string
3527                                 Base64SHA1 string
3528                         }
3529                         URL string
3530                 }))(obj)).Files)[local108]).Name))) > math.MaxUint16 {
3531                         chk(ErrTooLong)
3532                 }
3533                 {
3534                         x := uint16(len(([]byte((((*(*(struct {
3535                                 Files []struct {
3536                                         Name       string
3537                                         Base64SHA1 string
3538                                 }
3539                                 URL string
3540                         }))(obj)).Files)[local108]).Name))))
3541                         write16(w, uint16(x))
3542                 }
3543                 {
3544                         _, err := w.Write(([]byte((((*(*(struct {
3545                                 Files []struct {
3546                                         Name       string
3547                                         Base64SHA1 string
3548                                 }
3549                                 URL string
3550                         }))(obj)).Files)[local108]).Name))[:])
3551                         chk(err)
3552                 }
3553                 if len(([]byte((((*(*(struct {
3554                         Files []struct {
3555                                 Name       string
3556                                 Base64SHA1 string
3557                         }
3558                         URL string
3559                 }))(obj)).Files)[local108]).Base64SHA1))) > math.MaxUint16 {
3560                         chk(ErrTooLong)
3561                 }
3562                 {
3563                         x := uint16(len(([]byte((((*(*(struct {
3564                                 Files []struct {
3565                                         Name       string
3566                                         Base64SHA1 string
3567                                 }
3568                                 URL string
3569                         }))(obj)).Files)[local108]).Base64SHA1))))
3570                         write16(w, uint16(x))
3571                 }
3572                 {
3573                         _, err := w.Write(([]byte((((*(*(struct {
3574                                 Files []struct {
3575                                         Name       string
3576                                         Base64SHA1 string
3577                                 }
3578                                 URL string
3579                         }))(obj)).Files)[local108]).Base64SHA1))[:])
3580                         chk(err)
3581                 }
3582         }
3583         if len(([]byte((*(*(struct {
3584                 Files []struct {
3585                         Name       string
3586                         Base64SHA1 string
3587                 }
3588                 URL string
3589         }))(obj)).URL))) > math.MaxUint16 {
3590                 chk(ErrTooLong)
3591         }
3592         {
3593                 x := uint16(len(([]byte((*(*(struct {
3594                         Files []struct {
3595                                 Name       string
3596                                 Base64SHA1 string
3597                         }
3598                         URL string
3599                 }))(obj)).URL))))
3600                 write16(w, uint16(x))
3601         }
3602         {
3603                 _, err := w.Write(([]byte((*(*(struct {
3604                         Files []struct {
3605                                 Name       string
3606                                 Base64SHA1 string
3607                         }
3608                         URL string
3609                 }))(obj)).URL))[:])
3610                 chk(err)
3611         }
3612 }
3613
3614 func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
3615         var local109 uint16
3616         {
3617                 p := &local109
3618                 *p = read16(r)
3619         }
3620         ((*(*(struct {
3621                 Files []struct {
3622                         Name       string
3623                         Base64SHA1 string
3624                 }
3625                 URL string
3626         }))(obj)).Files) = make([]struct {
3627                 Name       string
3628                 Base64SHA1 string
3629         }, local109)
3630         for local110 := range (*(*(struct {
3631                 Files []struct {
3632                         Name       string
3633                         Base64SHA1 string
3634                 }
3635                 URL string
3636         }))(obj)).Files {
3637                 var local111 []uint8
3638                 var local112 uint16
3639                 {
3640                         p := &local112
3641                         *p = read16(r)
3642                 }
3643                 (local111) = make([]uint8, local112)
3644                 {
3645                         _, err := io.ReadFull(r, (local111)[:])
3646                         chk(err)
3647                 }
3648                 ((((*(*(struct {
3649                         Files []struct {
3650                                 Name       string
3651                                 Base64SHA1 string
3652                         }
3653                         URL string
3654                 }))(obj)).Files)[local110]).Name) = string(local111)
3655                 var local113 []uint8
3656                 var local114 uint16
3657                 {
3658                         p := &local114
3659                         *p = read16(r)
3660                 }
3661                 (local113) = make([]uint8, local114)
3662                 {
3663                         _, err := io.ReadFull(r, (local113)[:])
3664                         chk(err)
3665                 }
3666                 ((((*(*(struct {
3667                         Files []struct {
3668                                 Name       string
3669                                 Base64SHA1 string
3670                         }
3671                         URL string
3672                 }))(obj)).Files)[local110]).Base64SHA1) = string(local113)
3673         }
3674         var local115 []uint8
3675         var local116 uint16
3676         {
3677                 p := &local116
3678                 *p = read16(r)
3679         }
3680         (local115) = make([]uint8, local116)
3681         {
3682                 _, err := io.ReadFull(r, (local115)[:])
3683                 chk(err)
3684         }
3685         ((*(*(struct {
3686                 Files []struct {
3687                         Name       string
3688                         Base64SHA1 string
3689                 }
3690                 URL string
3691         }))(obj)).URL) = string(local115)
3692 }
3693
3694 func (obj *ToCltItemDefs) serialize(w io.Writer) {
3695         {
3696                 ow := w
3697                 w := new(bytes.Buffer)
3698                 {
3699                         w := zlib.NewWriter(w)
3700                         {
3701                                 local117 := uint8(0)
3702                                 {
3703                                         x := local117
3704                                         write8(w, uint8(x))
3705                                 }
3706                         }
3707                         if len(((*(*(struct {
3708                                 Defs    []ItemDef
3709                                 Aliases []struct{ Alias, Orig string }
3710                         }))(obj)).Defs)) > math.MaxUint16 {
3711                                 chk(ErrTooLong)
3712                         }
3713                         {
3714                                 x := uint16(len(((*(*(struct {
3715                                         Defs    []ItemDef
3716                                         Aliases []struct{ Alias, Orig string }
3717                                 }))(obj)).Defs)))
3718                                 write16(w, uint16(x))
3719                         }
3720                         for local118 := range (*(*(struct {
3721                                 Defs    []ItemDef
3722                                 Aliases []struct{ Alias, Orig string }
3723                         }))(obj)).Defs {
3724                                 if err := pcall(func() {
3725                                         (((*(*(struct {
3726                                                 Defs    []ItemDef
3727                                                 Aliases []struct{ Alias, Orig string }
3728                                         }))(obj)).Defs)[local118]).serialize(w)
3729                                 }); err != nil {
3730                                         if err == io.EOF {
3731                                                 chk(io.EOF)
3732                                         }
3733                                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemDef", err))
3734                                 }
3735                         }
3736                         if len(((*(*(struct {
3737                                 Defs    []ItemDef
3738                                 Aliases []struct{ Alias, Orig string }
3739                         }))(obj)).Aliases)) > math.MaxUint16 {
3740                                 chk(ErrTooLong)
3741                         }
3742                         {
3743                                 x := uint16(len(((*(*(struct {
3744                                         Defs    []ItemDef
3745                                         Aliases []struct{ Alias, Orig string }
3746                                 }))(obj)).Aliases)))
3747                                 write16(w, uint16(x))
3748                         }
3749                         for local119 := range (*(*(struct {
3750                                 Defs    []ItemDef
3751                                 Aliases []struct{ Alias, Orig string }
3752                         }))(obj)).Aliases {
3753                                 if len(([]byte((((*(*(struct {
3754                                         Defs    []ItemDef
3755                                         Aliases []struct{ Alias, Orig string }
3756                                 }))(obj)).Aliases)[local119]).Alias))) > math.MaxUint16 {
3757                                         chk(ErrTooLong)
3758                                 }
3759                                 {
3760                                         x := uint16(len(([]byte((((*(*(struct {
3761                                                 Defs    []ItemDef
3762                                                 Aliases []struct{ Alias, Orig string }
3763                                         }))(obj)).Aliases)[local119]).Alias))))
3764                                         write16(w, uint16(x))
3765                                 }
3766                                 {
3767                                         _, err := w.Write(([]byte((((*(*(struct {
3768                                                 Defs    []ItemDef
3769                                                 Aliases []struct{ Alias, Orig string }
3770                                         }))(obj)).Aliases)[local119]).Alias))[:])
3771                                         chk(err)
3772                                 }
3773                                 if len(([]byte((((*(*(struct {
3774                                         Defs    []ItemDef
3775                                         Aliases []struct{ Alias, Orig string }
3776                                 }))(obj)).Aliases)[local119]).Orig))) > math.MaxUint16 {
3777                                         chk(ErrTooLong)
3778                                 }
3779                                 {
3780                                         x := uint16(len(([]byte((((*(*(struct {
3781                                                 Defs    []ItemDef
3782                                                 Aliases []struct{ Alias, Orig string }
3783                                         }))(obj)).Aliases)[local119]).Orig))))
3784                                         write16(w, uint16(x))
3785                                 }
3786                                 {
3787                                         _, err := w.Write(([]byte((((*(*(struct {
3788                                                 Defs    []ItemDef
3789                                                 Aliases []struct{ Alias, Orig string }
3790                                         }))(obj)).Aliases)[local119]).Orig))[:])
3791                                         chk(err)
3792                                 }
3793                         }
3794                         chk(w.Close())
3795                 }
3796                 {
3797                         buf := w
3798                         w := ow
3799                         if len((buf.Bytes())) > math.MaxUint32 {
3800                                 chk(ErrTooLong)
3801                         }
3802                         {
3803                                 x := uint32(len((buf.Bytes())))
3804                                 write32(w, uint32(x))
3805                         }
3806                         {
3807                                 _, err := w.Write((buf.Bytes())[:])
3808                                 chk(err)
3809                         }
3810                 }
3811         }
3812 }
3813
3814 func (obj *ToCltItemDefs) deserialize(r io.Reader) {
3815         {
3816                 var n uint32
3817                 {
3818                         p := &n
3819                         *p = read32(r)
3820                 }
3821                 r := &io.LimitedReader{R: r, N: int64(n)}
3822                 {
3823                         r, err := zlib.NewReader(byteReader{r})
3824                         chk(err)
3825                         {
3826                                 var local120 uint8
3827                                 local121 := uint8(0)
3828                                 {
3829                                         p := &local120
3830                                         *p = read8(r)
3831                                 }
3832                                 if local120 != local121 {
3833                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local120))
3834                                 }
3835                         }
3836                         var local122 uint16
3837                         {
3838                                 p := &local122
3839                                 *p = read16(r)
3840                         }
3841                         ((*(*(struct {
3842                                 Defs    []ItemDef
3843                                 Aliases []struct{ Alias, Orig string }
3844                         }))(obj)).Defs) = make([]ItemDef, local122)
3845                         for local123 := range (*(*(struct {
3846                                 Defs    []ItemDef
3847                                 Aliases []struct{ Alias, Orig string }
3848                         }))(obj)).Defs {
3849                                 if err := pcall(func() {
3850                                         (((*(*(struct {
3851                                                 Defs    []ItemDef
3852                                                 Aliases []struct{ Alias, Orig string }
3853                                         }))(obj)).Defs)[local123]).deserialize(r)
3854                                 }); err != nil {
3855                                         if err == io.EOF {
3856                                                 chk(io.EOF)
3857                                         }
3858                                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemDef", err))
3859                                 }
3860                         }
3861                         var local124 uint16
3862                         {
3863                                 p := &local124
3864                                 *p = read16(r)
3865                         }
3866                         ((*(*(struct {
3867                                 Defs    []ItemDef
3868                                 Aliases []struct{ Alias, Orig string }
3869                         }))(obj)).Aliases) = make([]struct {
3870                                 Alias string
3871                                 Orig  string
3872                         }, local124)
3873                         for local125 := range (*(*(struct {
3874                                 Defs    []ItemDef
3875                                 Aliases []struct{ Alias, Orig string }
3876                         }))(obj)).Aliases {
3877                                 var local126 []uint8
3878                                 var local127 uint16
3879                                 {
3880                                         p := &local127
3881                                         *p = read16(r)
3882                                 }
3883                                 (local126) = make([]uint8, local127)
3884                                 {
3885                                         _, err := io.ReadFull(r, (local126)[:])
3886                                         chk(err)
3887                                 }
3888                                 ((((*(*(struct {
3889                                         Defs    []ItemDef
3890                                         Aliases []struct{ Alias, Orig string }
3891                                 }))(obj)).Aliases)[local125]).Alias) = string(local126)
3892                                 var local128 []uint8
3893                                 var local129 uint16
3894                                 {
3895                                         p := &local129
3896                                         *p = read16(r)
3897                                 }
3898                                 (local128) = make([]uint8, local129)
3899                                 {
3900                                         _, err := io.ReadFull(r, (local128)[:])
3901                                         chk(err)
3902                                 }
3903                                 ((((*(*(struct {
3904                                         Defs    []ItemDef
3905                                         Aliases []struct{ Alias, Orig string }
3906                                 }))(obj)).Aliases)[local125]).Orig) = string(local128)
3907                         }
3908                         chk(r.Close())
3909                 }
3910                 if r.N > 0 {
3911                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3912                 }
3913         }
3914 }
3915
3916 func (obj *ToCltPlaySound) serialize(w io.Writer) {
3917         if err := pcall(func() {
3918                 ((*(*(struct {
3919                         ID      SoundID
3920                         Name    string
3921                         Gain    float32
3922                         SrcType SoundSrcType
3923                         Pos
3924                         SrcAOID   AOID
3925                         Loop      bool
3926                         Fade      float32
3927                         Pitch     float32
3928                         Ephemeral bool
3929                 }))(obj)).ID).serialize(w)
3930         }); err != nil {
3931                 if err == io.EOF {
3932                         chk(io.EOF)
3933                 }
3934                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
3935         }
3936         if len(([]byte((*(*(struct {
3937                 ID      SoundID
3938                 Name    string
3939                 Gain    float32
3940                 SrcType SoundSrcType
3941                 Pos
3942                 SrcAOID   AOID
3943                 Loop      bool
3944                 Fade      float32
3945                 Pitch     float32
3946                 Ephemeral bool
3947         }))(obj)).Name))) > math.MaxUint16 {
3948                 chk(ErrTooLong)
3949         }
3950         {
3951                 x := uint16(len(([]byte((*(*(struct {
3952                         ID      SoundID
3953                         Name    string
3954                         Gain    float32
3955                         SrcType SoundSrcType
3956                         Pos
3957                         SrcAOID   AOID
3958                         Loop      bool
3959                         Fade      float32
3960                         Pitch     float32
3961                         Ephemeral bool
3962                 }))(obj)).Name))))
3963                 write16(w, uint16(x))
3964         }
3965         {
3966                 _, err := w.Write(([]byte((*(*(struct {
3967                         ID      SoundID
3968                         Name    string
3969                         Gain    float32
3970                         SrcType SoundSrcType
3971                         Pos
3972                         SrcAOID   AOID
3973                         Loop      bool
3974                         Fade      float32
3975                         Pitch     float32
3976                         Ephemeral bool
3977                 }))(obj)).Name))[:])
3978                 chk(err)
3979         }
3980         {
3981                 x := (*(*(struct {
3982                         ID      SoundID
3983                         Name    string
3984                         Gain    float32
3985                         SrcType SoundSrcType
3986                         Pos
3987                         SrcAOID   AOID
3988                         Loop      bool
3989                         Fade      float32
3990                         Pitch     float32
3991                         Ephemeral bool
3992                 }))(obj)).Gain
3993                 write32(w, math.Float32bits(x))
3994         }
3995         if err := pcall(func() {
3996                 ((*(*(struct {
3997                         ID      SoundID
3998                         Name    string
3999                         Gain    float32
4000                         SrcType SoundSrcType
4001                         Pos
4002                         SrcAOID   AOID
4003                         Loop      bool
4004                         Fade      float32
4005                         Pitch     float32
4006                         Ephemeral bool
4007                 }))(obj)).SrcType).serialize(w)
4008         }); err != nil {
4009                 if err == io.EOF {
4010                         chk(io.EOF)
4011                 }
4012                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundSrcType", err))
4013         }
4014         if err := pcall(func() {
4015                 ((*(*(struct {
4016                         ID      SoundID
4017                         Name    string
4018                         Gain    float32
4019                         SrcType SoundSrcType
4020                         Pos
4021                         SrcAOID   AOID
4022                         Loop      bool
4023                         Fade      float32
4024                         Pitch     float32
4025                         Ephemeral bool
4026                 }))(obj)).Pos).serialize(w)
4027         }); err != nil {
4028                 if err == io.EOF {
4029                         chk(io.EOF)
4030                 }
4031                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
4032         }
4033         if err := pcall(func() {
4034                 ((*(*(struct {
4035                         ID      SoundID
4036                         Name    string
4037                         Gain    float32
4038                         SrcType SoundSrcType
4039                         Pos
4040                         SrcAOID   AOID
4041                         Loop      bool
4042                         Fade      float32
4043                         Pitch     float32
4044                         Ephemeral bool
4045                 }))(obj)).SrcAOID).serialize(w)
4046         }); err != nil {
4047                 if err == io.EOF {
4048                         chk(io.EOF)
4049                 }
4050                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
4051         }
4052         {
4053                 x := (*(*(struct {
4054                         ID      SoundID
4055                         Name    string
4056                         Gain    float32
4057                         SrcType SoundSrcType
4058                         Pos
4059                         SrcAOID   AOID
4060                         Loop      bool
4061                         Fade      float32
4062                         Pitch     float32
4063                         Ephemeral bool
4064                 }))(obj)).Loop
4065                 if x {
4066                         write8(w, 1)
4067                 } else {
4068                         write8(w, 0)
4069                 }
4070         }
4071         {
4072                 x := (*(*(struct {
4073                         ID      SoundID
4074                         Name    string
4075                         Gain    float32
4076                         SrcType SoundSrcType
4077                         Pos
4078                         SrcAOID   AOID
4079                         Loop      bool
4080                         Fade      float32
4081                         Pitch     float32
4082                         Ephemeral bool
4083                 }))(obj)).Fade
4084                 write32(w, math.Float32bits(x))
4085         }
4086         {
4087                 x := (*(*(struct {
4088                         ID      SoundID
4089                         Name    string
4090                         Gain    float32
4091                         SrcType SoundSrcType
4092                         Pos
4093                         SrcAOID   AOID
4094                         Loop      bool
4095                         Fade      float32
4096                         Pitch     float32
4097                         Ephemeral bool
4098                 }))(obj)).Pitch
4099                 write32(w, math.Float32bits(x))
4100         }
4101         {
4102                 x := (*(*(struct {
4103                         ID      SoundID
4104                         Name    string
4105                         Gain    float32
4106                         SrcType SoundSrcType
4107                         Pos
4108                         SrcAOID   AOID
4109                         Loop      bool
4110                         Fade      float32
4111                         Pitch     float32
4112                         Ephemeral bool
4113                 }))(obj)).Ephemeral
4114                 if x {
4115                         write8(w, 1)
4116                 } else {
4117                         write8(w, 0)
4118                 }
4119         }
4120 }
4121
4122 func (obj *ToCltPlaySound) deserialize(r io.Reader) {
4123         if err := pcall(func() {
4124                 ((*(*(struct {
4125                         ID      SoundID
4126                         Name    string
4127                         Gain    float32
4128                         SrcType SoundSrcType
4129                         Pos
4130                         SrcAOID   AOID
4131                         Loop      bool
4132                         Fade      float32
4133                         Pitch     float32
4134                         Ephemeral bool
4135                 }))(obj)).ID).deserialize(r)
4136         }); err != nil {
4137                 if err == io.EOF {
4138                         chk(io.EOF)
4139                 }
4140                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4141         }
4142         var local130 []uint8
4143         var local131 uint16
4144         {
4145                 p := &local131
4146                 *p = read16(r)
4147         }
4148         (local130) = make([]uint8, local131)
4149         {
4150                 _, err := io.ReadFull(r, (local130)[:])
4151                 chk(err)
4152         }
4153         ((*(*(struct {
4154                 ID      SoundID
4155                 Name    string
4156                 Gain    float32
4157                 SrcType SoundSrcType
4158                 Pos
4159                 SrcAOID   AOID
4160                 Loop      bool
4161                 Fade      float32
4162                 Pitch     float32
4163                 Ephemeral bool
4164         }))(obj)).Name) = string(local130)
4165         {
4166                 p := &(*(*(struct {
4167                         ID      SoundID
4168                         Name    string
4169                         Gain    float32
4170                         SrcType SoundSrcType
4171                         Pos
4172                         SrcAOID   AOID
4173                         Loop      bool
4174                         Fade      float32
4175                         Pitch     float32
4176                         Ephemeral bool
4177                 }))(obj)).Gain
4178                 *p = math.Float32frombits(read32(r))
4179         }
4180         if err := pcall(func() {
4181                 ((*(*(struct {
4182                         ID      SoundID
4183                         Name    string
4184                         Gain    float32
4185                         SrcType SoundSrcType
4186                         Pos
4187                         SrcAOID   AOID
4188                         Loop      bool
4189                         Fade      float32
4190                         Pitch     float32
4191                         Ephemeral bool
4192                 }))(obj)).SrcType).deserialize(r)
4193         }); err != nil {
4194                 if err == io.EOF {
4195                         chk(io.EOF)
4196                 }
4197                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundSrcType", err))
4198         }
4199         if err := pcall(func() {
4200                 ((*(*(struct {
4201                         ID      SoundID
4202                         Name    string
4203                         Gain    float32
4204                         SrcType SoundSrcType
4205                         Pos
4206                         SrcAOID   AOID
4207                         Loop      bool
4208                         Fade      float32
4209                         Pitch     float32
4210                         Ephemeral bool
4211                 }))(obj)).Pos).deserialize(r)
4212         }); err != nil {
4213                 if err == io.EOF {
4214                         chk(io.EOF)
4215                 }
4216                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
4217         }
4218         if err := pcall(func() {
4219                 ((*(*(struct {
4220                         ID      SoundID
4221                         Name    string
4222                         Gain    float32
4223                         SrcType SoundSrcType
4224                         Pos
4225                         SrcAOID   AOID
4226                         Loop      bool
4227                         Fade      float32
4228                         Pitch     float32
4229                         Ephemeral bool
4230                 }))(obj)).SrcAOID).deserialize(r)
4231         }); err != nil {
4232                 if err == io.EOF {
4233                         chk(io.EOF)
4234                 }
4235                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
4236         }
4237         {
4238                 p := &(*(*(struct {
4239                         ID      SoundID
4240                         Name    string
4241                         Gain    float32
4242                         SrcType SoundSrcType
4243                         Pos
4244                         SrcAOID   AOID
4245                         Loop      bool
4246                         Fade      float32
4247                         Pitch     float32
4248                         Ephemeral bool
4249                 }))(obj)).Loop
4250                 switch n := read8(r); n {
4251                 case 0:
4252                         *p = false
4253                 case 1:
4254                         *p = true
4255                 default:
4256                         chk(fmt.Errorf("invalid bool: %d", n))
4257                 }
4258         }
4259         {
4260                 p := &(*(*(struct {
4261                         ID      SoundID
4262                         Name    string
4263                         Gain    float32
4264                         SrcType SoundSrcType
4265                         Pos
4266                         SrcAOID   AOID
4267                         Loop      bool
4268                         Fade      float32
4269                         Pitch     float32
4270                         Ephemeral bool
4271                 }))(obj)).Fade
4272                 *p = math.Float32frombits(read32(r))
4273         }
4274         {
4275                 p := &(*(*(struct {
4276                         ID      SoundID
4277                         Name    string
4278                         Gain    float32
4279                         SrcType SoundSrcType
4280                         Pos
4281                         SrcAOID   AOID
4282                         Loop      bool
4283                         Fade      float32
4284                         Pitch     float32
4285                         Ephemeral bool
4286                 }))(obj)).Pitch
4287                 *p = math.Float32frombits(read32(r))
4288         }
4289         {
4290                 p := &(*(*(struct {
4291                         ID      SoundID
4292                         Name    string
4293                         Gain    float32
4294                         SrcType SoundSrcType
4295                         Pos
4296                         SrcAOID   AOID
4297                         Loop      bool
4298                         Fade      float32
4299                         Pitch     float32
4300                         Ephemeral bool
4301                 }))(obj)).Ephemeral
4302                 switch n := read8(r); n {
4303                 case 0:
4304                         *p = false
4305                 case 1:
4306                         *p = true
4307                 default:
4308                         chk(fmt.Errorf("invalid bool: %d", n))
4309                 }
4310         }
4311 }
4312
4313 func (obj *ToCltStopSound) serialize(w io.Writer) {
4314         if err := pcall(func() {
4315                 ((*(*(struct {
4316                         ID SoundID
4317                 }))(obj)).ID).serialize(w)
4318         }); err != nil {
4319                 if err == io.EOF {
4320                         chk(io.EOF)
4321                 }
4322                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4323         }
4324 }
4325
4326 func (obj *ToCltStopSound) deserialize(r io.Reader) {
4327         if err := pcall(func() {
4328                 ((*(*(struct {
4329                         ID SoundID
4330                 }))(obj)).ID).deserialize(r)
4331         }); err != nil {
4332                 if err == io.EOF {
4333                         chk(io.EOF)
4334                 }
4335                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4336         }
4337 }
4338
4339 func (obj *ToCltPrivs) serialize(w io.Writer) {
4340         if len(((*(*(struct {
4341                 Privs []string
4342         }))(obj)).Privs)) > math.MaxUint16 {
4343                 chk(ErrTooLong)
4344         }
4345         {
4346                 x := uint16(len(((*(*(struct {
4347                         Privs []string
4348                 }))(obj)).Privs)))
4349                 write16(w, uint16(x))
4350         }
4351         for local132 := range (*(*(struct {
4352                 Privs []string
4353         }))(obj)).Privs {
4354                 if len(([]byte(((*(*(struct {
4355                         Privs []string
4356                 }))(obj)).Privs)[local132]))) > math.MaxUint16 {
4357                         chk(ErrTooLong)
4358                 }
4359                 {
4360                         x := uint16(len(([]byte(((*(*(struct {
4361                                 Privs []string
4362                         }))(obj)).Privs)[local132]))))
4363                         write16(w, uint16(x))
4364                 }
4365                 {
4366                         _, err := w.Write(([]byte(((*(*(struct {
4367                                 Privs []string
4368                         }))(obj)).Privs)[local132]))[:])
4369                         chk(err)
4370                 }
4371         }
4372 }
4373
4374 func (obj *ToCltPrivs) deserialize(r io.Reader) {
4375         var local133 uint16
4376         {
4377                 p := &local133
4378                 *p = read16(r)
4379         }
4380         ((*(*(struct {
4381                 Privs []string
4382         }))(obj)).Privs) = make([]string, local133)
4383         for local134 := range (*(*(struct {
4384                 Privs []string
4385         }))(obj)).Privs {
4386                 var local135 []uint8
4387                 var local136 uint16
4388                 {
4389                         p := &local136
4390                         *p = read16(r)
4391                 }
4392                 (local135) = make([]uint8, local136)
4393                 {
4394                         _, err := io.ReadFull(r, (local135)[:])
4395                         chk(err)
4396                 }
4397                 (((*(*(struct {
4398                         Privs []string
4399                 }))(obj)).Privs)[local134]) = string(local135)
4400         }
4401 }
4402
4403 func (obj *ToCltInvFormspec) serialize(w io.Writer) {
4404         if len(([]byte((*(*(struct {
4405                 //mt:len32
4406                 Formspec string
4407         }))(obj)).Formspec))) > math.MaxUint32 {
4408                 chk(ErrTooLong)
4409         }
4410         {
4411                 x := uint32(len(([]byte((*(*(struct {
4412                         //mt:len32
4413                         Formspec string
4414                 }))(obj)).Formspec))))
4415                 write32(w, uint32(x))
4416         }
4417         {
4418                 _, err := w.Write(([]byte((*(*(struct {
4419                         //mt:len32
4420                         Formspec string
4421                 }))(obj)).Formspec))[:])
4422                 chk(err)
4423         }
4424 }
4425
4426 func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
4427         var local137 []uint8
4428         var local138 uint32
4429         {
4430                 p := &local138
4431                 *p = read32(r)
4432         }
4433         (local137) = make([]uint8, local138)
4434         {
4435                 _, err := io.ReadFull(r, (local137)[:])
4436                 chk(err)
4437         }
4438         ((*(*(struct {
4439                 //mt:len32
4440                 Formspec string
4441         }))(obj)).Formspec) = string(local137)
4442 }
4443
4444 func (obj *ToCltDetachedInv) serialize(w io.Writer) {
4445         if len(([]byte((*(*(struct {
4446                 Name string
4447                 Keep bool
4448                 Len  uint16 // deprecated
4449
4450                 //mt:raw
4451                 Inv string
4452         }))(obj)).Name))) > math.MaxUint16 {
4453                 chk(ErrTooLong)
4454         }
4455         {
4456                 x := uint16(len(([]byte((*(*(struct {
4457                         Name string
4458                         Keep bool
4459                         Len  uint16 // deprecated
4460
4461                         //mt:raw
4462                         Inv string
4463                 }))(obj)).Name))))
4464                 write16(w, uint16(x))
4465         }
4466         {
4467                 _, err := w.Write(([]byte((*(*(struct {
4468                         Name string
4469                         Keep bool
4470                         Len  uint16 // deprecated
4471
4472                         //mt:raw
4473                         Inv string
4474                 }))(obj)).Name))[:])
4475                 chk(err)
4476         }
4477         {
4478                 x := (*(*(struct {
4479                         Name string
4480                         Keep bool
4481                         Len  uint16 // deprecated
4482
4483                         //mt:raw
4484                         Inv string
4485                 }))(obj)).Keep
4486                 if x {
4487                         write8(w, 1)
4488                 } else {
4489                         write8(w, 0)
4490                 }
4491         }
4492         {
4493                 x := (*(*(struct {
4494                         Name string
4495                         Keep bool
4496                         Len  uint16 // deprecated
4497
4498                         //mt:raw
4499                         Inv string
4500                 }))(obj)).Len
4501                 write16(w, uint16(x))
4502         }
4503         {
4504                 _, err := w.Write(([]byte((*(*(struct {
4505                         Name string
4506                         Keep bool
4507                         Len  uint16 // deprecated
4508
4509                         //mt:raw
4510                         Inv string
4511                 }))(obj)).Inv))[:])
4512                 chk(err)
4513         }
4514 }
4515
4516 func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
4517         var local139 []uint8
4518         var local140 uint16
4519         {
4520                 p := &local140
4521                 *p = read16(r)
4522         }
4523         (local139) = make([]uint8, local140)
4524         {
4525                 _, err := io.ReadFull(r, (local139)[:])
4526                 chk(err)
4527         }
4528         ((*(*(struct {
4529                 Name string
4530                 Keep bool
4531                 Len  uint16 // deprecated
4532
4533                 //mt:raw
4534                 Inv string
4535         }))(obj)).Name) = string(local139)
4536         {
4537                 p := &(*(*(struct {
4538                         Name string
4539                         Keep bool
4540                         Len  uint16 // deprecated
4541
4542                         //mt:raw
4543                         Inv string
4544                 }))(obj)).Keep
4545                 switch n := read8(r); n {
4546                 case 0:
4547                         *p = false
4548                 case 1:
4549                         *p = true
4550                 default:
4551                         chk(fmt.Errorf("invalid bool: %d", n))
4552                 }
4553         }
4554         {
4555                 p := &(*(*(struct {
4556                         Name string
4557                         Keep bool
4558                         Len  uint16 // deprecated
4559
4560                         //mt:raw
4561                         Inv string
4562                 }))(obj)).Len
4563                 *p = read16(r)
4564         }
4565         var local141 []uint8
4566         {
4567                 var err error
4568                 (local141), err = io.ReadAll(r)
4569                 chk(err)
4570         }
4571         ((*(*(struct {
4572                 Name string
4573                 Keep bool
4574                 Len  uint16 // deprecated
4575
4576                 //mt:raw
4577                 Inv string
4578         }))(obj)).Inv) = string(local141)
4579 }
4580
4581 func (obj *ToCltShowFormspec) serialize(w io.Writer) {
4582         if len(([]byte((*(*(struct {
4583                 //mt:len32
4584                 Formspec string
4585
4586                 Formname string
4587         }))(obj)).Formspec))) > math.MaxUint32 {
4588                 chk(ErrTooLong)
4589         }
4590         {
4591                 x := uint32(len(([]byte((*(*(struct {
4592                         //mt:len32
4593                         Formspec string
4594
4595                         Formname string
4596                 }))(obj)).Formspec))))
4597                 write32(w, uint32(x))
4598         }
4599         {
4600                 _, err := w.Write(([]byte((*(*(struct {
4601                         //mt:len32
4602                         Formspec string
4603
4604                         Formname string
4605                 }))(obj)).Formspec))[:])
4606                 chk(err)
4607         }
4608         if len(([]byte((*(*(struct {
4609                 //mt:len32
4610                 Formspec string
4611
4612                 Formname string
4613         }))(obj)).Formname))) > math.MaxUint16 {
4614                 chk(ErrTooLong)
4615         }
4616         {
4617                 x := uint16(len(([]byte((*(*(struct {
4618                         //mt:len32
4619                         Formspec string
4620
4621                         Formname string
4622                 }))(obj)).Formname))))
4623                 write16(w, uint16(x))
4624         }
4625         {
4626                 _, err := w.Write(([]byte((*(*(struct {
4627                         //mt:len32
4628                         Formspec string
4629
4630                         Formname string
4631                 }))(obj)).Formname))[:])
4632                 chk(err)
4633         }
4634 }
4635
4636 func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
4637         var local142 []uint8
4638         var local143 uint32
4639         {
4640                 p := &local143
4641                 *p = read32(r)
4642         }
4643         (local142) = make([]uint8, local143)
4644         {
4645                 _, err := io.ReadFull(r, (local142)[:])
4646                 chk(err)
4647         }
4648         ((*(*(struct {
4649                 //mt:len32
4650                 Formspec string
4651
4652                 Formname string
4653         }))(obj)).Formspec) = string(local142)
4654         var local144 []uint8
4655         var local145 uint16
4656         {
4657                 p := &local145
4658                 *p = read16(r)
4659         }
4660         (local144) = make([]uint8, local145)
4661         {
4662                 _, err := io.ReadFull(r, (local144)[:])
4663                 chk(err)
4664         }
4665         ((*(*(struct {
4666                 //mt:len32
4667                 Formspec string
4668
4669                 Formname string
4670         }))(obj)).Formname) = string(local144)
4671 }
4672
4673 func (obj *ToCltMovement) serialize(w io.Writer) {
4674         {
4675                 x := (*(*(struct {
4676                         DefaultAccel, AirAccel, FastAccel,
4677                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4678                         Fluidity, Smoothing, Sink,
4679                         Gravity float32
4680                 }))(obj)).DefaultAccel
4681                 write32(w, math.Float32bits(x))
4682         }
4683         {
4684                 x := (*(*(struct {
4685                         DefaultAccel, AirAccel, FastAccel,
4686                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4687                         Fluidity, Smoothing, Sink,
4688                         Gravity float32
4689                 }))(obj)).AirAccel
4690                 write32(w, math.Float32bits(x))
4691         }
4692         {
4693                 x := (*(*(struct {
4694                         DefaultAccel, AirAccel, FastAccel,
4695                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4696                         Fluidity, Smoothing, Sink,
4697                         Gravity float32
4698                 }))(obj)).FastAccel
4699                 write32(w, math.Float32bits(x))
4700         }
4701         {
4702                 x := (*(*(struct {
4703                         DefaultAccel, AirAccel, FastAccel,
4704                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4705                         Fluidity, Smoothing, Sink,
4706                         Gravity float32
4707                 }))(obj)).WalkSpeed
4708                 write32(w, math.Float32bits(x))
4709         }
4710         {
4711                 x := (*(*(struct {
4712                         DefaultAccel, AirAccel, FastAccel,
4713                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4714                         Fluidity, Smoothing, Sink,
4715                         Gravity float32
4716                 }))(obj)).CrouchSpeed
4717                 write32(w, math.Float32bits(x))
4718         }
4719         {
4720                 x := (*(*(struct {
4721                         DefaultAccel, AirAccel, FastAccel,
4722                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4723                         Fluidity, Smoothing, Sink,
4724                         Gravity float32
4725                 }))(obj)).FastSpeed
4726                 write32(w, math.Float32bits(x))
4727         }
4728         {
4729                 x := (*(*(struct {
4730                         DefaultAccel, AirAccel, FastAccel,
4731                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4732                         Fluidity, Smoothing, Sink,
4733                         Gravity float32
4734                 }))(obj)).ClimbSpeed
4735                 write32(w, math.Float32bits(x))
4736         }
4737         {
4738                 x := (*(*(struct {
4739                         DefaultAccel, AirAccel, FastAccel,
4740                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4741                         Fluidity, Smoothing, Sink,
4742                         Gravity float32
4743                 }))(obj)).JumpSpeed
4744                 write32(w, math.Float32bits(x))
4745         }
4746         {
4747                 x := (*(*(struct {
4748                         DefaultAccel, AirAccel, FastAccel,
4749                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4750                         Fluidity, Smoothing, Sink,
4751                         Gravity float32
4752                 }))(obj)).Fluidity
4753                 write32(w, math.Float32bits(x))
4754         }
4755         {
4756                 x := (*(*(struct {
4757                         DefaultAccel, AirAccel, FastAccel,
4758                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4759                         Fluidity, Smoothing, Sink,
4760                         Gravity float32
4761                 }))(obj)).Smoothing
4762                 write32(w, math.Float32bits(x))
4763         }
4764         {
4765                 x := (*(*(struct {
4766                         DefaultAccel, AirAccel, FastAccel,
4767                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4768                         Fluidity, Smoothing, Sink,
4769                         Gravity float32
4770                 }))(obj)).Sink
4771                 write32(w, math.Float32bits(x))
4772         }
4773         {
4774                 x := (*(*(struct {
4775                         DefaultAccel, AirAccel, FastAccel,
4776                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4777                         Fluidity, Smoothing, Sink,
4778                         Gravity float32
4779                 }))(obj)).Gravity
4780                 write32(w, math.Float32bits(x))
4781         }
4782 }
4783
4784 func (obj *ToCltMovement) deserialize(r io.Reader) {
4785         {
4786                 p := &(*(*(struct {
4787                         DefaultAccel, AirAccel, FastAccel,
4788                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4789                         Fluidity, Smoothing, Sink,
4790                         Gravity float32
4791                 }))(obj)).DefaultAccel
4792                 *p = math.Float32frombits(read32(r))
4793         }
4794         {
4795                 p := &(*(*(struct {
4796                         DefaultAccel, AirAccel, FastAccel,
4797                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4798                         Fluidity, Smoothing, Sink,
4799                         Gravity float32
4800                 }))(obj)).AirAccel
4801                 *p = math.Float32frombits(read32(r))
4802         }
4803         {
4804                 p := &(*(*(struct {
4805                         DefaultAccel, AirAccel, FastAccel,
4806                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4807                         Fluidity, Smoothing, Sink,
4808                         Gravity float32
4809                 }))(obj)).FastAccel
4810                 *p = math.Float32frombits(read32(r))
4811         }
4812         {
4813                 p := &(*(*(struct {
4814                         DefaultAccel, AirAccel, FastAccel,
4815                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4816                         Fluidity, Smoothing, Sink,
4817                         Gravity float32
4818                 }))(obj)).WalkSpeed
4819                 *p = math.Float32frombits(read32(r))
4820         }
4821         {
4822                 p := &(*(*(struct {
4823                         DefaultAccel, AirAccel, FastAccel,
4824                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4825                         Fluidity, Smoothing, Sink,
4826                         Gravity float32
4827                 }))(obj)).CrouchSpeed
4828                 *p = math.Float32frombits(read32(r))
4829         }
4830         {
4831                 p := &(*(*(struct {
4832                         DefaultAccel, AirAccel, FastAccel,
4833                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4834                         Fluidity, Smoothing, Sink,
4835                         Gravity float32
4836                 }))(obj)).FastSpeed
4837                 *p = math.Float32frombits(read32(r))
4838         }
4839         {
4840                 p := &(*(*(struct {
4841                         DefaultAccel, AirAccel, FastAccel,
4842                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4843                         Fluidity, Smoothing, Sink,
4844                         Gravity float32
4845                 }))(obj)).ClimbSpeed
4846                 *p = math.Float32frombits(read32(r))
4847         }
4848         {
4849                 p := &(*(*(struct {
4850                         DefaultAccel, AirAccel, FastAccel,
4851                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4852                         Fluidity, Smoothing, Sink,
4853                         Gravity float32
4854                 }))(obj)).JumpSpeed
4855                 *p = math.Float32frombits(read32(r))
4856         }
4857         {
4858                 p := &(*(*(struct {
4859                         DefaultAccel, AirAccel, FastAccel,
4860                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4861                         Fluidity, Smoothing, Sink,
4862                         Gravity float32
4863                 }))(obj)).Fluidity
4864                 *p = math.Float32frombits(read32(r))
4865         }
4866         {
4867                 p := &(*(*(struct {
4868                         DefaultAccel, AirAccel, FastAccel,
4869                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4870                         Fluidity, Smoothing, Sink,
4871                         Gravity float32
4872                 }))(obj)).Smoothing
4873                 *p = math.Float32frombits(read32(r))
4874         }
4875         {
4876                 p := &(*(*(struct {
4877                         DefaultAccel, AirAccel, FastAccel,
4878                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4879                         Fluidity, Smoothing, Sink,
4880                         Gravity float32
4881                 }))(obj)).Sink
4882                 *p = math.Float32frombits(read32(r))
4883         }
4884         {
4885                 p := &(*(*(struct {
4886                         DefaultAccel, AirAccel, FastAccel,
4887                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4888                         Fluidity, Smoothing, Sink,
4889                         Gravity float32
4890                 }))(obj)).Gravity
4891                 *p = math.Float32frombits(read32(r))
4892         }
4893 }
4894
4895 func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
4896         for local146 := range (*(*(struct {
4897                 Pos, Vel, Acc  [3]float32
4898                 ExpirationTime float32 // in seconds.
4899                 Size           float32
4900                 Collide        bool
4901
4902                 //mt:len32
4903                 Texture
4904
4905                 Vertical    bool
4906                 CollisionRm bool
4907                 AnimParams  TileAnim
4908                 Glow        uint8
4909                 AOCollision bool
4910                 NodeParam0  Content
4911                 NodeParam2  uint8
4912                 NodeTile    uint8
4913         }))(obj)).Pos {
4914                 {
4915                         x := ((*(*(struct {
4916                                 Pos, Vel, Acc  [3]float32
4917                                 ExpirationTime float32 // in seconds.
4918                                 Size           float32
4919                                 Collide        bool
4920
4921                                 //mt:len32
4922                                 Texture
4923
4924                                 Vertical    bool
4925                                 CollisionRm bool
4926                                 AnimParams  TileAnim
4927                                 Glow        uint8
4928                                 AOCollision bool
4929                                 NodeParam0  Content
4930                                 NodeParam2  uint8
4931                                 NodeTile    uint8
4932                         }))(obj)).Pos)[local146]
4933                         write32(w, math.Float32bits(x))
4934                 }
4935         }
4936         for local147 := range (*(*(struct {
4937                 Pos, Vel, Acc  [3]float32
4938                 ExpirationTime float32 // in seconds.
4939                 Size           float32
4940                 Collide        bool
4941
4942                 //mt:len32
4943                 Texture
4944
4945                 Vertical    bool
4946                 CollisionRm bool
4947                 AnimParams  TileAnim
4948                 Glow        uint8
4949                 AOCollision bool
4950                 NodeParam0  Content
4951                 NodeParam2  uint8
4952                 NodeTile    uint8
4953         }))(obj)).Vel {
4954                 {
4955                         x := ((*(*(struct {
4956                                 Pos, Vel, Acc  [3]float32
4957                                 ExpirationTime float32 // in seconds.
4958                                 Size           float32
4959                                 Collide        bool
4960
4961                                 //mt:len32
4962                                 Texture
4963
4964                                 Vertical    bool
4965                                 CollisionRm bool
4966                                 AnimParams  TileAnim
4967                                 Glow        uint8
4968                                 AOCollision bool
4969                                 NodeParam0  Content
4970                                 NodeParam2  uint8
4971                                 NodeTile    uint8
4972                         }))(obj)).Vel)[local147]
4973                         write32(w, math.Float32bits(x))
4974                 }
4975         }
4976         for local148 := range (*(*(struct {
4977                 Pos, Vel, Acc  [3]float32
4978                 ExpirationTime float32 // in seconds.
4979                 Size           float32
4980                 Collide        bool
4981
4982                 //mt:len32
4983                 Texture
4984
4985                 Vertical    bool
4986                 CollisionRm bool
4987                 AnimParams  TileAnim
4988                 Glow        uint8
4989                 AOCollision bool
4990                 NodeParam0  Content
4991                 NodeParam2  uint8
4992                 NodeTile    uint8
4993         }))(obj)).Acc {
4994                 {
4995                         x := ((*(*(struct {
4996                                 Pos, Vel, Acc  [3]float32
4997                                 ExpirationTime float32 // in seconds.
4998                                 Size           float32
4999                                 Collide        bool
5000
5001                                 //mt:len32
5002                                 Texture
5003
5004                                 Vertical    bool
5005                                 CollisionRm bool
5006                                 AnimParams  TileAnim
5007                                 Glow        uint8
5008                                 AOCollision bool
5009                                 NodeParam0  Content
5010                                 NodeParam2  uint8
5011                                 NodeTile    uint8
5012                         }))(obj)).Acc)[local148]
5013                         write32(w, math.Float32bits(x))
5014                 }
5015         }
5016         {
5017                 x := (*(*(struct {
5018                         Pos, Vel, Acc  [3]float32
5019                         ExpirationTime float32 // in seconds.
5020                         Size           float32
5021                         Collide        bool
5022
5023                         //mt:len32
5024                         Texture
5025
5026                         Vertical    bool
5027                         CollisionRm bool
5028                         AnimParams  TileAnim
5029                         Glow        uint8
5030                         AOCollision bool
5031                         NodeParam0  Content
5032                         NodeParam2  uint8
5033                         NodeTile    uint8
5034                 }))(obj)).ExpirationTime
5035                 write32(w, math.Float32bits(x))
5036         }
5037         {
5038                 x := (*(*(struct {
5039                         Pos, Vel, Acc  [3]float32
5040                         ExpirationTime float32 // in seconds.
5041                         Size           float32
5042                         Collide        bool
5043
5044                         //mt:len32
5045                         Texture
5046
5047                         Vertical    bool
5048                         CollisionRm bool
5049                         AnimParams  TileAnim
5050                         Glow        uint8
5051                         AOCollision bool
5052                         NodeParam0  Content
5053                         NodeParam2  uint8
5054                         NodeTile    uint8
5055                 }))(obj)).Size
5056                 write32(w, math.Float32bits(x))
5057         }
5058         {
5059                 x := (*(*(struct {
5060                         Pos, Vel, Acc  [3]float32
5061                         ExpirationTime float32 // in seconds.
5062                         Size           float32
5063                         Collide        bool
5064
5065                         //mt:len32
5066                         Texture
5067
5068                         Vertical    bool
5069                         CollisionRm bool
5070                         AnimParams  TileAnim
5071                         Glow        uint8
5072                         AOCollision bool
5073                         NodeParam0  Content
5074                         NodeParam2  uint8
5075                         NodeTile    uint8
5076                 }))(obj)).Collide
5077                 if x {
5078                         write8(w, 1)
5079                 } else {
5080                         write8(w, 0)
5081                 }
5082         }
5083         if len(([]byte(*(*string)(&((*(*(struct {
5084                 Pos, Vel, Acc  [3]float32
5085                 ExpirationTime float32 // in seconds.
5086                 Size           float32
5087                 Collide        bool
5088
5089                 //mt:len32
5090                 Texture
5091
5092                 Vertical    bool
5093                 CollisionRm bool
5094                 AnimParams  TileAnim
5095                 Glow        uint8
5096                 AOCollision bool
5097                 NodeParam0  Content
5098                 NodeParam2  uint8
5099                 NodeTile    uint8
5100         }))(obj)).Texture))))) > math.MaxUint32 {
5101                 chk(ErrTooLong)
5102         }
5103         {
5104                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5105                         Pos, Vel, Acc  [3]float32
5106                         ExpirationTime float32 // in seconds.
5107                         Size           float32
5108                         Collide        bool
5109
5110                         //mt:len32
5111                         Texture
5112
5113                         Vertical    bool
5114                         CollisionRm bool
5115                         AnimParams  TileAnim
5116                         Glow        uint8
5117                         AOCollision bool
5118                         NodeParam0  Content
5119                         NodeParam2  uint8
5120                         NodeTile    uint8
5121                 }))(obj)).Texture))))))
5122                 write32(w, uint32(x))
5123         }
5124         {
5125                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5126                         Pos, Vel, Acc  [3]float32
5127                         ExpirationTime float32 // in seconds.
5128                         Size           float32
5129                         Collide        bool
5130
5131                         //mt:len32
5132                         Texture
5133
5134                         Vertical    bool
5135                         CollisionRm bool
5136                         AnimParams  TileAnim
5137                         Glow        uint8
5138                         AOCollision bool
5139                         NodeParam0  Content
5140                         NodeParam2  uint8
5141                         NodeTile    uint8
5142                 }))(obj)).Texture))))[:])
5143                 chk(err)
5144         }
5145         {
5146                 x := (*(*(struct {
5147                         Pos, Vel, Acc  [3]float32
5148                         ExpirationTime float32 // in seconds.
5149                         Size           float32
5150                         Collide        bool
5151
5152                         //mt:len32
5153                         Texture
5154
5155                         Vertical    bool
5156                         CollisionRm bool
5157                         AnimParams  TileAnim
5158                         Glow        uint8
5159                         AOCollision bool
5160                         NodeParam0  Content
5161                         NodeParam2  uint8
5162                         NodeTile    uint8
5163                 }))(obj)).Vertical
5164                 if x {
5165                         write8(w, 1)
5166                 } else {
5167                         write8(w, 0)
5168                 }
5169         }
5170         {
5171                 x := (*(*(struct {
5172                         Pos, Vel, Acc  [3]float32
5173                         ExpirationTime float32 // in seconds.
5174                         Size           float32
5175                         Collide        bool
5176
5177                         //mt:len32
5178                         Texture
5179
5180                         Vertical    bool
5181                         CollisionRm bool
5182                         AnimParams  TileAnim
5183                         Glow        uint8
5184                         AOCollision bool
5185                         NodeParam0  Content
5186                         NodeParam2  uint8
5187                         NodeTile    uint8
5188                 }))(obj)).CollisionRm
5189                 if x {
5190                         write8(w, 1)
5191                 } else {
5192                         write8(w, 0)
5193                 }
5194         }
5195         if err := pcall(func() {
5196                 ((*(*(struct {
5197                         Pos, Vel, Acc  [3]float32
5198                         ExpirationTime float32 // in seconds.
5199                         Size           float32
5200                         Collide        bool
5201
5202                         //mt:len32
5203                         Texture
5204
5205                         Vertical    bool
5206                         CollisionRm bool
5207                         AnimParams  TileAnim
5208                         Glow        uint8
5209                         AOCollision bool
5210                         NodeParam0  Content
5211                         NodeParam2  uint8
5212                         NodeTile    uint8
5213                 }))(obj)).AnimParams).serialize(w)
5214         }); err != nil {
5215                 if err == io.EOF {
5216                         chk(io.EOF)
5217                 }
5218                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
5219         }
5220         {
5221                 x := (*(*(struct {
5222                         Pos, Vel, Acc  [3]float32
5223                         ExpirationTime float32 // in seconds.
5224                         Size           float32
5225                         Collide        bool
5226
5227                         //mt:len32
5228                         Texture
5229
5230                         Vertical    bool
5231                         CollisionRm bool
5232                         AnimParams  TileAnim
5233                         Glow        uint8
5234                         AOCollision bool
5235                         NodeParam0  Content
5236                         NodeParam2  uint8
5237                         NodeTile    uint8
5238                 }))(obj)).Glow
5239                 write8(w, uint8(x))
5240         }
5241         {
5242                 x := (*(*(struct {
5243                         Pos, Vel, Acc  [3]float32
5244                         ExpirationTime float32 // in seconds.
5245                         Size           float32
5246                         Collide        bool
5247
5248                         //mt:len32
5249                         Texture
5250
5251                         Vertical    bool
5252                         CollisionRm bool
5253                         AnimParams  TileAnim
5254                         Glow        uint8
5255                         AOCollision bool
5256                         NodeParam0  Content
5257                         NodeParam2  uint8
5258                         NodeTile    uint8
5259                 }))(obj)).AOCollision
5260                 if x {
5261                         write8(w, 1)
5262                 } else {
5263                         write8(w, 0)
5264                 }
5265         }
5266         if err := pcall(func() {
5267                 ((*(*(struct {
5268                         Pos, Vel, Acc  [3]float32
5269                         ExpirationTime float32 // in seconds.
5270                         Size           float32
5271                         Collide        bool
5272
5273                         //mt:len32
5274                         Texture
5275
5276                         Vertical    bool
5277                         CollisionRm bool
5278                         AnimParams  TileAnim
5279                         Glow        uint8
5280                         AOCollision bool
5281                         NodeParam0  Content
5282                         NodeParam2  uint8
5283                         NodeTile    uint8
5284                 }))(obj)).NodeParam0).serialize(w)
5285         }); err != nil {
5286                 if err == io.EOF {
5287                         chk(io.EOF)
5288                 }
5289                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
5290         }
5291         {
5292                 x := (*(*(struct {
5293                         Pos, Vel, Acc  [3]float32
5294                         ExpirationTime float32 // in seconds.
5295                         Size           float32
5296                         Collide        bool
5297
5298                         //mt:len32
5299                         Texture
5300
5301                         Vertical    bool
5302                         CollisionRm bool
5303                         AnimParams  TileAnim
5304                         Glow        uint8
5305                         AOCollision bool
5306                         NodeParam0  Content
5307                         NodeParam2  uint8
5308                         NodeTile    uint8
5309                 }))(obj)).NodeParam2
5310                 write8(w, uint8(x))
5311         }
5312         {
5313                 x := (*(*(struct {
5314                         Pos, Vel, Acc  [3]float32
5315                         ExpirationTime float32 // in seconds.
5316                         Size           float32
5317                         Collide        bool
5318
5319                         //mt:len32
5320                         Texture
5321
5322                         Vertical    bool
5323                         CollisionRm bool
5324                         AnimParams  TileAnim
5325                         Glow        uint8
5326                         AOCollision bool
5327                         NodeParam0  Content
5328                         NodeParam2  uint8
5329                         NodeTile    uint8
5330                 }))(obj)).NodeTile
5331                 write8(w, uint8(x))
5332         }
5333 }
5334
5335 func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
5336         for local149 := range (*(*(struct {
5337                 Pos, Vel, Acc  [3]float32
5338                 ExpirationTime float32 // in seconds.
5339                 Size           float32
5340                 Collide        bool
5341
5342                 //mt:len32
5343                 Texture
5344
5345                 Vertical    bool
5346                 CollisionRm bool
5347                 AnimParams  TileAnim
5348                 Glow        uint8
5349                 AOCollision bool
5350                 NodeParam0  Content
5351                 NodeParam2  uint8
5352                 NodeTile    uint8
5353         }))(obj)).Pos {
5354                 {
5355                         p := &((*(*(struct {
5356                                 Pos, Vel, Acc  [3]float32
5357                                 ExpirationTime float32 // in seconds.
5358                                 Size           float32
5359                                 Collide        bool
5360
5361                                 //mt:len32
5362                                 Texture
5363
5364                                 Vertical    bool
5365                                 CollisionRm bool
5366                                 AnimParams  TileAnim
5367                                 Glow        uint8
5368                                 AOCollision bool
5369                                 NodeParam0  Content
5370                                 NodeParam2  uint8
5371                                 NodeTile    uint8
5372                         }))(obj)).Pos)[local149]
5373                         *p = math.Float32frombits(read32(r))
5374                 }
5375         }
5376         for local150 := range (*(*(struct {
5377                 Pos, Vel, Acc  [3]float32
5378                 ExpirationTime float32 // in seconds.
5379                 Size           float32
5380                 Collide        bool
5381
5382                 //mt:len32
5383                 Texture
5384
5385                 Vertical    bool
5386                 CollisionRm bool
5387                 AnimParams  TileAnim
5388                 Glow        uint8
5389                 AOCollision bool
5390                 NodeParam0  Content
5391                 NodeParam2  uint8
5392                 NodeTile    uint8
5393         }))(obj)).Vel {
5394                 {
5395                         p := &((*(*(struct {
5396                                 Pos, Vel, Acc  [3]float32
5397                                 ExpirationTime float32 // in seconds.
5398                                 Size           float32
5399                                 Collide        bool
5400
5401                                 //mt:len32
5402                                 Texture
5403
5404                                 Vertical    bool
5405                                 CollisionRm bool
5406                                 AnimParams  TileAnim
5407                                 Glow        uint8
5408                                 AOCollision bool
5409                                 NodeParam0  Content
5410                                 NodeParam2  uint8
5411                                 NodeTile    uint8
5412                         }))(obj)).Vel)[local150]
5413                         *p = math.Float32frombits(read32(r))
5414                 }
5415         }
5416         for local151 := range (*(*(struct {
5417                 Pos, Vel, Acc  [3]float32
5418                 ExpirationTime float32 // in seconds.
5419                 Size           float32
5420                 Collide        bool
5421
5422                 //mt:len32
5423                 Texture
5424
5425                 Vertical    bool
5426                 CollisionRm bool
5427                 AnimParams  TileAnim
5428                 Glow        uint8
5429                 AOCollision bool
5430                 NodeParam0  Content
5431                 NodeParam2  uint8
5432                 NodeTile    uint8
5433         }))(obj)).Acc {
5434                 {
5435                         p := &((*(*(struct {
5436                                 Pos, Vel, Acc  [3]float32
5437                                 ExpirationTime float32 // in seconds.
5438                                 Size           float32
5439                                 Collide        bool
5440
5441                                 //mt:len32
5442                                 Texture
5443
5444                                 Vertical    bool
5445                                 CollisionRm bool
5446                                 AnimParams  TileAnim
5447                                 Glow        uint8
5448                                 AOCollision bool
5449                                 NodeParam0  Content
5450                                 NodeParam2  uint8
5451                                 NodeTile    uint8
5452                         }))(obj)).Acc)[local151]
5453                         *p = math.Float32frombits(read32(r))
5454                 }
5455         }
5456         {
5457                 p := &(*(*(struct {
5458                         Pos, Vel, Acc  [3]float32
5459                         ExpirationTime float32 // in seconds.
5460                         Size           float32
5461                         Collide        bool
5462
5463                         //mt:len32
5464                         Texture
5465
5466                         Vertical    bool
5467                         CollisionRm bool
5468                         AnimParams  TileAnim
5469                         Glow        uint8
5470                         AOCollision bool
5471                         NodeParam0  Content
5472                         NodeParam2  uint8
5473                         NodeTile    uint8
5474                 }))(obj)).ExpirationTime
5475                 *p = math.Float32frombits(read32(r))
5476         }
5477         {
5478                 p := &(*(*(struct {
5479                         Pos, Vel, Acc  [3]float32
5480                         ExpirationTime float32 // in seconds.
5481                         Size           float32
5482                         Collide        bool
5483
5484                         //mt:len32
5485                         Texture
5486
5487                         Vertical    bool
5488                         CollisionRm bool
5489                         AnimParams  TileAnim
5490                         Glow        uint8
5491                         AOCollision bool
5492                         NodeParam0  Content
5493                         NodeParam2  uint8
5494                         NodeTile    uint8
5495                 }))(obj)).Size
5496                 *p = math.Float32frombits(read32(r))
5497         }
5498         {
5499                 p := &(*(*(struct {
5500                         Pos, Vel, Acc  [3]float32
5501                         ExpirationTime float32 // in seconds.
5502                         Size           float32
5503                         Collide        bool
5504
5505                         //mt:len32
5506                         Texture
5507
5508                         Vertical    bool
5509                         CollisionRm bool
5510                         AnimParams  TileAnim
5511                         Glow        uint8
5512                         AOCollision bool
5513                         NodeParam0  Content
5514                         NodeParam2  uint8
5515                         NodeTile    uint8
5516                 }))(obj)).Collide
5517                 switch n := read8(r); n {
5518                 case 0:
5519                         *p = false
5520                 case 1:
5521                         *p = true
5522                 default:
5523                         chk(fmt.Errorf("invalid bool: %d", n))
5524                 }
5525         }
5526         var local152 []uint8
5527         var local153 uint32
5528         {
5529                 p := &local153
5530                 *p = read32(r)
5531         }
5532         (local152) = make([]uint8, local153)
5533         {
5534                 _, err := io.ReadFull(r, (local152)[:])
5535                 chk(err)
5536         }
5537         (*(*string)(&((*(*(struct {
5538                 Pos, Vel, Acc  [3]float32
5539                 ExpirationTime float32 // in seconds.
5540                 Size           float32
5541                 Collide        bool
5542
5543                 //mt:len32
5544                 Texture
5545
5546                 Vertical    bool
5547                 CollisionRm bool
5548                 AnimParams  TileAnim
5549                 Glow        uint8
5550                 AOCollision bool
5551                 NodeParam0  Content
5552                 NodeParam2  uint8
5553                 NodeTile    uint8
5554         }))(obj)).Texture))) = string(local152)
5555         {
5556                 p := &(*(*(struct {
5557                         Pos, Vel, Acc  [3]float32
5558                         ExpirationTime float32 // in seconds.
5559                         Size           float32
5560                         Collide        bool
5561
5562                         //mt:len32
5563                         Texture
5564
5565                         Vertical    bool
5566                         CollisionRm bool
5567                         AnimParams  TileAnim
5568                         Glow        uint8
5569                         AOCollision bool
5570                         NodeParam0  Content
5571                         NodeParam2  uint8
5572                         NodeTile    uint8
5573                 }))(obj)).Vertical
5574                 switch n := read8(r); n {
5575                 case 0:
5576                         *p = false
5577                 case 1:
5578                         *p = true
5579                 default:
5580                         chk(fmt.Errorf("invalid bool: %d", n))
5581                 }
5582         }
5583         {
5584                 p := &(*(*(struct {
5585                         Pos, Vel, Acc  [3]float32
5586                         ExpirationTime float32 // in seconds.
5587                         Size           float32
5588                         Collide        bool
5589
5590                         //mt:len32
5591                         Texture
5592
5593                         Vertical    bool
5594                         CollisionRm bool
5595                         AnimParams  TileAnim
5596                         Glow        uint8
5597                         AOCollision bool
5598                         NodeParam0  Content
5599                         NodeParam2  uint8
5600                         NodeTile    uint8
5601                 }))(obj)).CollisionRm
5602                 switch n := read8(r); n {
5603                 case 0:
5604                         *p = false
5605                 case 1:
5606                         *p = true
5607                 default:
5608                         chk(fmt.Errorf("invalid bool: %d", n))
5609                 }
5610         }
5611         if err := pcall(func() {
5612                 ((*(*(struct {
5613                         Pos, Vel, Acc  [3]float32
5614                         ExpirationTime float32 // in seconds.
5615                         Size           float32
5616                         Collide        bool
5617
5618                         //mt:len32
5619                         Texture
5620
5621                         Vertical    bool
5622                         CollisionRm bool
5623                         AnimParams  TileAnim
5624                         Glow        uint8
5625                         AOCollision bool
5626                         NodeParam0  Content
5627                         NodeParam2  uint8
5628                         NodeTile    uint8
5629                 }))(obj)).AnimParams).deserialize(r)
5630         }); err != nil {
5631                 if err == io.EOF {
5632                         chk(io.EOF)
5633                 }
5634                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
5635         }
5636         {
5637                 p := &(*(*(struct {
5638                         Pos, Vel, Acc  [3]float32
5639                         ExpirationTime float32 // in seconds.
5640                         Size           float32
5641                         Collide        bool
5642
5643                         //mt:len32
5644                         Texture
5645
5646                         Vertical    bool
5647                         CollisionRm bool
5648                         AnimParams  TileAnim
5649                         Glow        uint8
5650                         AOCollision bool
5651                         NodeParam0  Content
5652                         NodeParam2  uint8
5653                         NodeTile    uint8
5654                 }))(obj)).Glow
5655                 *p = read8(r)
5656         }
5657         {
5658                 p := &(*(*(struct {
5659                         Pos, Vel, Acc  [3]float32
5660                         ExpirationTime float32 // in seconds.
5661                         Size           float32
5662                         Collide        bool
5663
5664                         //mt:len32
5665                         Texture
5666
5667                         Vertical    bool
5668                         CollisionRm bool
5669                         AnimParams  TileAnim
5670                         Glow        uint8
5671                         AOCollision bool
5672                         NodeParam0  Content
5673                         NodeParam2  uint8
5674                         NodeTile    uint8
5675                 }))(obj)).AOCollision
5676                 switch n := read8(r); n {
5677                 case 0:
5678                         *p = false
5679                 case 1:
5680                         *p = true
5681                 default:
5682                         chk(fmt.Errorf("invalid bool: %d", n))
5683                 }
5684         }
5685         if err := pcall(func() {
5686                 ((*(*(struct {
5687                         Pos, Vel, Acc  [3]float32
5688                         ExpirationTime float32 // in seconds.
5689                         Size           float32
5690                         Collide        bool
5691
5692                         //mt:len32
5693                         Texture
5694
5695                         Vertical    bool
5696                         CollisionRm bool
5697                         AnimParams  TileAnim
5698                         Glow        uint8
5699                         AOCollision bool
5700                         NodeParam0  Content
5701                         NodeParam2  uint8
5702                         NodeTile    uint8
5703                 }))(obj)).NodeParam0).deserialize(r)
5704         }); err != nil {
5705                 if err == io.EOF {
5706                         chk(io.EOF)
5707                 }
5708                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
5709         }
5710         {
5711                 p := &(*(*(struct {
5712                         Pos, Vel, Acc  [3]float32
5713                         ExpirationTime float32 // in seconds.
5714                         Size           float32
5715                         Collide        bool
5716
5717                         //mt:len32
5718                         Texture
5719
5720                         Vertical    bool
5721                         CollisionRm bool
5722                         AnimParams  TileAnim
5723                         Glow        uint8
5724                         AOCollision bool
5725                         NodeParam0  Content
5726                         NodeParam2  uint8
5727                         NodeTile    uint8
5728                 }))(obj)).NodeParam2
5729                 *p = read8(r)
5730         }
5731         {
5732                 p := &(*(*(struct {
5733                         Pos, Vel, Acc  [3]float32
5734                         ExpirationTime float32 // in seconds.
5735                         Size           float32
5736                         Collide        bool
5737
5738                         //mt:len32
5739                         Texture
5740
5741                         Vertical    bool
5742                         CollisionRm bool
5743                         AnimParams  TileAnim
5744                         Glow        uint8
5745                         AOCollision bool
5746                         NodeParam0  Content
5747                         NodeParam2  uint8
5748                         NodeTile    uint8
5749                 }))(obj)).NodeTile
5750                 *p = read8(r)
5751         }
5752 }
5753
5754 func (obj *ToCltAddParticleSpawner) serialize(w io.Writer) {
5755         {
5756                 x := (*(*(struct {
5757                         Amount         uint16
5758                         Duration       float32
5759                         Pos, Vel, Acc  [2][3]float32
5760                         ExpirationTime [2]float32 // in seconds.
5761                         Size           [2]float32
5762                         Collide        bool
5763
5764                         //mt:len32
5765                         Texture
5766
5767                         ID           ParticleSpawnerID
5768                         Vertical     bool
5769                         CollisionRm  bool
5770                         AttachedAOID AOID
5771                         AnimParams   TileAnim
5772                         Glow         uint8
5773                         AOCollision  bool
5774                         NodeParam0   Content
5775                         NodeParam2   uint8
5776                         NodeTile     uint8
5777                 }))(obj)).Amount
5778                 write16(w, uint16(x))
5779         }
5780         {
5781                 x := (*(*(struct {
5782                         Amount         uint16
5783                         Duration       float32
5784                         Pos, Vel, Acc  [2][3]float32
5785                         ExpirationTime [2]float32 // in seconds.
5786                         Size           [2]float32
5787                         Collide        bool
5788
5789                         //mt:len32
5790                         Texture
5791
5792                         ID           ParticleSpawnerID
5793                         Vertical     bool
5794                         CollisionRm  bool
5795                         AttachedAOID AOID
5796                         AnimParams   TileAnim
5797                         Glow         uint8
5798                         AOCollision  bool
5799                         NodeParam0   Content
5800                         NodeParam2   uint8
5801                         NodeTile     uint8
5802                 }))(obj)).Duration
5803                 write32(w, math.Float32bits(x))
5804         }
5805         for local154 := range (*(*(struct {
5806                 Amount         uint16
5807                 Duration       float32
5808                 Pos, Vel, Acc  [2][3]float32
5809                 ExpirationTime [2]float32 // in seconds.
5810                 Size           [2]float32
5811                 Collide        bool
5812
5813                 //mt:len32
5814                 Texture
5815
5816                 ID           ParticleSpawnerID
5817                 Vertical     bool
5818                 CollisionRm  bool
5819                 AttachedAOID AOID
5820                 AnimParams   TileAnim
5821                 Glow         uint8
5822                 AOCollision  bool
5823                 NodeParam0   Content
5824                 NodeParam2   uint8
5825                 NodeTile     uint8
5826         }))(obj)).Pos {
5827                 for local155 := range ((*(*(struct {
5828                         Amount         uint16
5829                         Duration       float32
5830                         Pos, Vel, Acc  [2][3]float32
5831                         ExpirationTime [2]float32 // in seconds.
5832                         Size           [2]float32
5833                         Collide        bool
5834
5835                         //mt:len32
5836                         Texture
5837
5838                         ID           ParticleSpawnerID
5839                         Vertical     bool
5840                         CollisionRm  bool
5841                         AttachedAOID AOID
5842                         AnimParams   TileAnim
5843                         Glow         uint8
5844                         AOCollision  bool
5845                         NodeParam0   Content
5846                         NodeParam2   uint8
5847                         NodeTile     uint8
5848                 }))(obj)).Pos)[local154] {
5849                         {
5850                                 x := (((*(*(struct {
5851                                         Amount         uint16
5852                                         Duration       float32
5853                                         Pos, Vel, Acc  [2][3]float32
5854                                         ExpirationTime [2]float32 // in seconds.
5855                                         Size           [2]float32
5856                                         Collide        bool
5857
5858                                         //mt:len32
5859                                         Texture
5860
5861                                         ID           ParticleSpawnerID
5862                                         Vertical     bool
5863                                         CollisionRm  bool
5864                                         AttachedAOID AOID
5865                                         AnimParams   TileAnim
5866                                         Glow         uint8
5867                                         AOCollision  bool
5868                                         NodeParam0   Content
5869                                         NodeParam2   uint8
5870                                         NodeTile     uint8
5871                                 }))(obj)).Pos)[local154])[local155]
5872                                 write32(w, math.Float32bits(x))
5873                         }
5874                 }
5875         }
5876         for local156 := range (*(*(struct {
5877                 Amount         uint16
5878                 Duration       float32
5879                 Pos, Vel, Acc  [2][3]float32
5880                 ExpirationTime [2]float32 // in seconds.
5881                 Size           [2]float32
5882                 Collide        bool
5883
5884                 //mt:len32
5885                 Texture
5886
5887                 ID           ParticleSpawnerID
5888                 Vertical     bool
5889                 CollisionRm  bool
5890                 AttachedAOID AOID
5891                 AnimParams   TileAnim
5892                 Glow         uint8
5893                 AOCollision  bool
5894                 NodeParam0   Content
5895                 NodeParam2   uint8
5896                 NodeTile     uint8
5897         }))(obj)).Vel {
5898                 for local157 := range ((*(*(struct {
5899                         Amount         uint16
5900                         Duration       float32
5901                         Pos, Vel, Acc  [2][3]float32
5902                         ExpirationTime [2]float32 // in seconds.
5903                         Size           [2]float32
5904                         Collide        bool
5905
5906                         //mt:len32
5907                         Texture
5908
5909                         ID           ParticleSpawnerID
5910                         Vertical     bool
5911                         CollisionRm  bool
5912                         AttachedAOID AOID
5913                         AnimParams   TileAnim
5914                         Glow         uint8
5915                         AOCollision  bool
5916                         NodeParam0   Content
5917                         NodeParam2   uint8
5918                         NodeTile     uint8
5919                 }))(obj)).Vel)[local156] {
5920                         {
5921                                 x := (((*(*(struct {
5922                                         Amount         uint16
5923                                         Duration       float32
5924                                         Pos, Vel, Acc  [2][3]float32
5925                                         ExpirationTime [2]float32 // in seconds.
5926                                         Size           [2]float32
5927                                         Collide        bool
5928
5929                                         //mt:len32
5930                                         Texture
5931
5932                                         ID           ParticleSpawnerID
5933                                         Vertical     bool
5934                                         CollisionRm  bool
5935                                         AttachedAOID AOID
5936                                         AnimParams   TileAnim
5937                                         Glow         uint8
5938                                         AOCollision  bool
5939                                         NodeParam0   Content
5940                                         NodeParam2   uint8
5941                                         NodeTile     uint8
5942                                 }))(obj)).Vel)[local156])[local157]
5943                                 write32(w, math.Float32bits(x))
5944                         }
5945                 }
5946         }
5947         for local158 := range (*(*(struct {
5948                 Amount         uint16
5949                 Duration       float32
5950                 Pos, Vel, Acc  [2][3]float32
5951                 ExpirationTime [2]float32 // in seconds.
5952                 Size           [2]float32
5953                 Collide        bool
5954
5955                 //mt:len32
5956                 Texture
5957
5958                 ID           ParticleSpawnerID
5959                 Vertical     bool
5960                 CollisionRm  bool
5961                 AttachedAOID AOID
5962                 AnimParams   TileAnim
5963                 Glow         uint8
5964                 AOCollision  bool
5965                 NodeParam0   Content
5966                 NodeParam2   uint8
5967                 NodeTile     uint8
5968         }))(obj)).Acc {
5969                 for local159 := range ((*(*(struct {
5970                         Amount         uint16
5971                         Duration       float32
5972                         Pos, Vel, Acc  [2][3]float32
5973                         ExpirationTime [2]float32 // in seconds.
5974                         Size           [2]float32
5975                         Collide        bool
5976
5977                         //mt:len32
5978                         Texture
5979
5980                         ID           ParticleSpawnerID
5981                         Vertical     bool
5982                         CollisionRm  bool
5983                         AttachedAOID AOID
5984                         AnimParams   TileAnim
5985                         Glow         uint8
5986                         AOCollision  bool
5987                         NodeParam0   Content
5988                         NodeParam2   uint8
5989                         NodeTile     uint8
5990                 }))(obj)).Acc)[local158] {
5991                         {
5992                                 x := (((*(*(struct {
5993                                         Amount         uint16
5994                                         Duration       float32
5995                                         Pos, Vel, Acc  [2][3]float32
5996                                         ExpirationTime [2]float32 // in seconds.
5997                                         Size           [2]float32
5998                                         Collide        bool
5999
6000                                         //mt:len32
6001                                         Texture
6002
6003                                         ID           ParticleSpawnerID
6004                                         Vertical     bool
6005                                         CollisionRm  bool
6006                                         AttachedAOID AOID
6007                                         AnimParams   TileAnim
6008                                         Glow         uint8
6009                                         AOCollision  bool
6010                                         NodeParam0   Content
6011                                         NodeParam2   uint8
6012                                         NodeTile     uint8
6013                                 }))(obj)).Acc)[local158])[local159]
6014                                 write32(w, math.Float32bits(x))
6015                         }
6016                 }
6017         }
6018         for local160 := range (*(*(struct {
6019                 Amount         uint16
6020                 Duration       float32
6021                 Pos, Vel, Acc  [2][3]float32
6022                 ExpirationTime [2]float32 // in seconds.
6023                 Size           [2]float32
6024                 Collide        bool
6025
6026                 //mt:len32
6027                 Texture
6028
6029                 ID           ParticleSpawnerID
6030                 Vertical     bool
6031                 CollisionRm  bool
6032                 AttachedAOID AOID
6033                 AnimParams   TileAnim
6034                 Glow         uint8
6035                 AOCollision  bool
6036                 NodeParam0   Content
6037                 NodeParam2   uint8
6038                 NodeTile     uint8
6039         }))(obj)).ExpirationTime {
6040                 {
6041                         x := ((*(*(struct {
6042                                 Amount         uint16
6043                                 Duration       float32
6044                                 Pos, Vel, Acc  [2][3]float32
6045                                 ExpirationTime [2]float32 // in seconds.
6046                                 Size           [2]float32
6047                                 Collide        bool
6048
6049                                 //mt:len32
6050                                 Texture
6051
6052                                 ID           ParticleSpawnerID
6053                                 Vertical     bool
6054                                 CollisionRm  bool
6055                                 AttachedAOID AOID
6056                                 AnimParams   TileAnim
6057                                 Glow         uint8
6058                                 AOCollision  bool
6059                                 NodeParam0   Content
6060                                 NodeParam2   uint8
6061                                 NodeTile     uint8
6062                         }))(obj)).ExpirationTime)[local160]
6063                         write32(w, math.Float32bits(x))
6064                 }
6065         }
6066         for local161 := range (*(*(struct {
6067                 Amount         uint16
6068                 Duration       float32
6069                 Pos, Vel, Acc  [2][3]float32
6070                 ExpirationTime [2]float32 // in seconds.
6071                 Size           [2]float32
6072                 Collide        bool
6073
6074                 //mt:len32
6075                 Texture
6076
6077                 ID           ParticleSpawnerID
6078                 Vertical     bool
6079                 CollisionRm  bool
6080                 AttachedAOID AOID
6081                 AnimParams   TileAnim
6082                 Glow         uint8
6083                 AOCollision  bool
6084                 NodeParam0   Content
6085                 NodeParam2   uint8
6086                 NodeTile     uint8
6087         }))(obj)).Size {
6088                 {
6089                         x := ((*(*(struct {
6090                                 Amount         uint16
6091                                 Duration       float32
6092                                 Pos, Vel, Acc  [2][3]float32
6093                                 ExpirationTime [2]float32 // in seconds.
6094                                 Size           [2]float32
6095                                 Collide        bool
6096
6097                                 //mt:len32
6098                                 Texture
6099
6100                                 ID           ParticleSpawnerID
6101                                 Vertical     bool
6102                                 CollisionRm  bool
6103                                 AttachedAOID AOID
6104                                 AnimParams   TileAnim
6105                                 Glow         uint8
6106                                 AOCollision  bool
6107                                 NodeParam0   Content
6108                                 NodeParam2   uint8
6109                                 NodeTile     uint8
6110                         }))(obj)).Size)[local161]
6111                         write32(w, math.Float32bits(x))
6112                 }
6113         }
6114         {
6115                 x := (*(*(struct {
6116                         Amount         uint16
6117                         Duration       float32
6118                         Pos, Vel, Acc  [2][3]float32
6119                         ExpirationTime [2]float32 // in seconds.
6120                         Size           [2]float32
6121                         Collide        bool
6122
6123                         //mt:len32
6124                         Texture
6125
6126                         ID           ParticleSpawnerID
6127                         Vertical     bool
6128                         CollisionRm  bool
6129                         AttachedAOID AOID
6130                         AnimParams   TileAnim
6131                         Glow         uint8
6132                         AOCollision  bool
6133                         NodeParam0   Content
6134                         NodeParam2   uint8
6135                         NodeTile     uint8
6136                 }))(obj)).Collide
6137                 if x {
6138                         write8(w, 1)
6139                 } else {
6140                         write8(w, 0)
6141                 }
6142         }
6143         if len(([]byte(*(*string)(&((*(*(struct {
6144                 Amount         uint16
6145                 Duration       float32
6146                 Pos, Vel, Acc  [2][3]float32
6147                 ExpirationTime [2]float32 // in seconds.
6148                 Size           [2]float32
6149                 Collide        bool
6150
6151                 //mt:len32
6152                 Texture
6153
6154                 ID           ParticleSpawnerID
6155                 Vertical     bool
6156                 CollisionRm  bool
6157                 AttachedAOID AOID
6158                 AnimParams   TileAnim
6159                 Glow         uint8
6160                 AOCollision  bool
6161                 NodeParam0   Content
6162                 NodeParam2   uint8
6163                 NodeTile     uint8
6164         }))(obj)).Texture))))) > math.MaxUint32 {
6165                 chk(ErrTooLong)
6166         }
6167         {
6168                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6169                         Amount         uint16
6170                         Duration       float32
6171                         Pos, Vel, Acc  [2][3]float32
6172                         ExpirationTime [2]float32 // in seconds.
6173                         Size           [2]float32
6174                         Collide        bool
6175
6176                         //mt:len32
6177                         Texture
6178
6179                         ID           ParticleSpawnerID
6180                         Vertical     bool
6181                         CollisionRm  bool
6182                         AttachedAOID AOID
6183                         AnimParams   TileAnim
6184                         Glow         uint8
6185                         AOCollision  bool
6186                         NodeParam0   Content
6187                         NodeParam2   uint8
6188                         NodeTile     uint8
6189                 }))(obj)).Texture))))))
6190                 write32(w, uint32(x))
6191         }
6192         {
6193                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6194                         Amount         uint16
6195                         Duration       float32
6196                         Pos, Vel, Acc  [2][3]float32
6197                         ExpirationTime [2]float32 // in seconds.
6198                         Size           [2]float32
6199                         Collide        bool
6200
6201                         //mt:len32
6202                         Texture
6203
6204                         ID           ParticleSpawnerID
6205                         Vertical     bool
6206                         CollisionRm  bool
6207                         AttachedAOID AOID
6208                         AnimParams   TileAnim
6209                         Glow         uint8
6210                         AOCollision  bool
6211                         NodeParam0   Content
6212                         NodeParam2   uint8
6213                         NodeTile     uint8
6214                 }))(obj)).Texture))))[:])
6215                 chk(err)
6216         }
6217         if err := pcall(func() {
6218                 ((*(*(struct {
6219                         Amount         uint16
6220                         Duration       float32
6221                         Pos, Vel, Acc  [2][3]float32
6222                         ExpirationTime [2]float32 // in seconds.
6223                         Size           [2]float32
6224                         Collide        bool
6225
6226                         //mt:len32
6227                         Texture
6228
6229                         ID           ParticleSpawnerID
6230                         Vertical     bool
6231                         CollisionRm  bool
6232                         AttachedAOID AOID
6233                         AnimParams   TileAnim
6234                         Glow         uint8
6235                         AOCollision  bool
6236                         NodeParam0   Content
6237                         NodeParam2   uint8
6238                         NodeTile     uint8
6239                 }))(obj)).ID).serialize(w)
6240         }); err != nil {
6241                 if err == io.EOF {
6242                         chk(io.EOF)
6243                 }
6244                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
6245         }
6246         {
6247                 x := (*(*(struct {
6248                         Amount         uint16
6249                         Duration       float32
6250                         Pos, Vel, Acc  [2][3]float32
6251                         ExpirationTime [2]float32 // in seconds.
6252                         Size           [2]float32
6253                         Collide        bool
6254
6255                         //mt:len32
6256                         Texture
6257
6258                         ID           ParticleSpawnerID
6259                         Vertical     bool
6260                         CollisionRm  bool
6261                         AttachedAOID AOID
6262                         AnimParams   TileAnim
6263                         Glow         uint8
6264                         AOCollision  bool
6265                         NodeParam0   Content
6266                         NodeParam2   uint8
6267                         NodeTile     uint8
6268                 }))(obj)).Vertical
6269                 if x {
6270                         write8(w, 1)
6271                 } else {
6272                         write8(w, 0)
6273                 }
6274         }
6275         {
6276                 x := (*(*(struct {
6277                         Amount         uint16
6278                         Duration       float32
6279                         Pos, Vel, Acc  [2][3]float32
6280                         ExpirationTime [2]float32 // in seconds.
6281                         Size           [2]float32
6282                         Collide        bool
6283
6284                         //mt:len32
6285                         Texture
6286
6287                         ID           ParticleSpawnerID
6288                         Vertical     bool
6289                         CollisionRm  bool
6290                         AttachedAOID AOID
6291                         AnimParams   TileAnim
6292                         Glow         uint8
6293                         AOCollision  bool
6294                         NodeParam0   Content
6295                         NodeParam2   uint8
6296                         NodeTile     uint8
6297                 }))(obj)).CollisionRm
6298                 if x {
6299                         write8(w, 1)
6300                 } else {
6301                         write8(w, 0)
6302                 }
6303         }
6304         if err := pcall(func() {
6305                 ((*(*(struct {
6306                         Amount         uint16
6307                         Duration       float32
6308                         Pos, Vel, Acc  [2][3]float32
6309                         ExpirationTime [2]float32 // in seconds.
6310                         Size           [2]float32
6311                         Collide        bool
6312
6313                         //mt:len32
6314                         Texture
6315
6316                         ID           ParticleSpawnerID
6317                         Vertical     bool
6318                         CollisionRm  bool
6319                         AttachedAOID AOID
6320                         AnimParams   TileAnim
6321                         Glow         uint8
6322                         AOCollision  bool
6323                         NodeParam0   Content
6324                         NodeParam2   uint8
6325                         NodeTile     uint8
6326                 }))(obj)).AttachedAOID).serialize(w)
6327         }); err != nil {
6328                 if err == io.EOF {
6329                         chk(io.EOF)
6330                 }
6331                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
6332         }
6333         if err := pcall(func() {
6334                 ((*(*(struct {
6335                         Amount         uint16
6336                         Duration       float32
6337                         Pos, Vel, Acc  [2][3]float32
6338                         ExpirationTime [2]float32 // in seconds.
6339                         Size           [2]float32
6340                         Collide        bool
6341
6342                         //mt:len32
6343                         Texture
6344
6345                         ID           ParticleSpawnerID
6346                         Vertical     bool
6347                         CollisionRm  bool
6348                         AttachedAOID AOID
6349                         AnimParams   TileAnim
6350                         Glow         uint8
6351                         AOCollision  bool
6352                         NodeParam0   Content
6353                         NodeParam2   uint8
6354                         NodeTile     uint8
6355                 }))(obj)).AnimParams).serialize(w)
6356         }); err != nil {
6357                 if err == io.EOF {
6358                         chk(io.EOF)
6359                 }
6360                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
6361         }
6362         {
6363                 x := (*(*(struct {
6364                         Amount         uint16
6365                         Duration       float32
6366                         Pos, Vel, Acc  [2][3]float32
6367                         ExpirationTime [2]float32 // in seconds.
6368                         Size           [2]float32
6369                         Collide        bool
6370
6371                         //mt:len32
6372                         Texture
6373
6374                         ID           ParticleSpawnerID
6375                         Vertical     bool
6376                         CollisionRm  bool
6377                         AttachedAOID AOID
6378                         AnimParams   TileAnim
6379                         Glow         uint8
6380                         AOCollision  bool
6381                         NodeParam0   Content
6382                         NodeParam2   uint8
6383                         NodeTile     uint8
6384                 }))(obj)).Glow
6385                 write8(w, uint8(x))
6386         }
6387         {
6388                 x := (*(*(struct {
6389                         Amount         uint16
6390                         Duration       float32
6391                         Pos, Vel, Acc  [2][3]float32
6392                         ExpirationTime [2]float32 // in seconds.
6393                         Size           [2]float32
6394                         Collide        bool
6395
6396                         //mt:len32
6397                         Texture
6398
6399                         ID           ParticleSpawnerID
6400                         Vertical     bool
6401                         CollisionRm  bool
6402                         AttachedAOID AOID
6403                         AnimParams   TileAnim
6404                         Glow         uint8
6405                         AOCollision  bool
6406                         NodeParam0   Content
6407                         NodeParam2   uint8
6408                         NodeTile     uint8
6409                 }))(obj)).AOCollision
6410                 if x {
6411                         write8(w, 1)
6412                 } else {
6413                         write8(w, 0)
6414                 }
6415         }
6416         if err := pcall(func() {
6417                 ((*(*(struct {
6418                         Amount         uint16
6419                         Duration       float32
6420                         Pos, Vel, Acc  [2][3]float32
6421                         ExpirationTime [2]float32 // in seconds.
6422                         Size           [2]float32
6423                         Collide        bool
6424
6425                         //mt:len32
6426                         Texture
6427
6428                         ID           ParticleSpawnerID
6429                         Vertical     bool
6430                         CollisionRm  bool
6431                         AttachedAOID AOID
6432                         AnimParams   TileAnim
6433                         Glow         uint8
6434                         AOCollision  bool
6435                         NodeParam0   Content
6436                         NodeParam2   uint8
6437                         NodeTile     uint8
6438                 }))(obj)).NodeParam0).serialize(w)
6439         }); err != nil {
6440                 if err == io.EOF {
6441                         chk(io.EOF)
6442                 }
6443                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
6444         }
6445         {
6446                 x := (*(*(struct {
6447                         Amount         uint16
6448                         Duration       float32
6449                         Pos, Vel, Acc  [2][3]float32
6450                         ExpirationTime [2]float32 // in seconds.
6451                         Size           [2]float32
6452                         Collide        bool
6453
6454                         //mt:len32
6455                         Texture
6456
6457                         ID           ParticleSpawnerID
6458                         Vertical     bool
6459                         CollisionRm  bool
6460                         AttachedAOID AOID
6461                         AnimParams   TileAnim
6462                         Glow         uint8
6463                         AOCollision  bool
6464                         NodeParam0   Content
6465                         NodeParam2   uint8
6466                         NodeTile     uint8
6467                 }))(obj)).NodeParam2
6468                 write8(w, uint8(x))
6469         }
6470         {
6471                 x := (*(*(struct {
6472                         Amount         uint16
6473                         Duration       float32
6474                         Pos, Vel, Acc  [2][3]float32
6475                         ExpirationTime [2]float32 // in seconds.
6476                         Size           [2]float32
6477                         Collide        bool
6478
6479                         //mt:len32
6480                         Texture
6481
6482                         ID           ParticleSpawnerID
6483                         Vertical     bool
6484                         CollisionRm  bool
6485                         AttachedAOID AOID
6486                         AnimParams   TileAnim
6487                         Glow         uint8
6488                         AOCollision  bool
6489                         NodeParam0   Content
6490                         NodeParam2   uint8
6491                         NodeTile     uint8
6492                 }))(obj)).NodeTile
6493                 write8(w, uint8(x))
6494         }
6495 }
6496
6497 func (obj *ToCltAddParticleSpawner) deserialize(r io.Reader) {
6498         {
6499                 p := &(*(*(struct {
6500                         Amount         uint16
6501                         Duration       float32
6502                         Pos, Vel, Acc  [2][3]float32
6503                         ExpirationTime [2]float32 // in seconds.
6504                         Size           [2]float32
6505                         Collide        bool
6506
6507                         //mt:len32
6508                         Texture
6509
6510                         ID           ParticleSpawnerID
6511                         Vertical     bool
6512                         CollisionRm  bool
6513                         AttachedAOID AOID
6514                         AnimParams   TileAnim
6515                         Glow         uint8
6516                         AOCollision  bool
6517                         NodeParam0   Content
6518                         NodeParam2   uint8
6519                         NodeTile     uint8
6520                 }))(obj)).Amount
6521                 *p = read16(r)
6522         }
6523         {
6524                 p := &(*(*(struct {
6525                         Amount         uint16
6526                         Duration       float32
6527                         Pos, Vel, Acc  [2][3]float32
6528                         ExpirationTime [2]float32 // in seconds.
6529                         Size           [2]float32
6530                         Collide        bool
6531
6532                         //mt:len32
6533                         Texture
6534
6535                         ID           ParticleSpawnerID
6536                         Vertical     bool
6537                         CollisionRm  bool
6538                         AttachedAOID AOID
6539                         AnimParams   TileAnim
6540                         Glow         uint8
6541                         AOCollision  bool
6542                         NodeParam0   Content
6543                         NodeParam2   uint8
6544                         NodeTile     uint8
6545                 }))(obj)).Duration
6546                 *p = math.Float32frombits(read32(r))
6547         }
6548         for local162 := range (*(*(struct {
6549                 Amount         uint16
6550                 Duration       float32
6551                 Pos, Vel, Acc  [2][3]float32
6552                 ExpirationTime [2]float32 // in seconds.
6553                 Size           [2]float32
6554                 Collide        bool
6555
6556                 //mt:len32
6557                 Texture
6558
6559                 ID           ParticleSpawnerID
6560                 Vertical     bool
6561                 CollisionRm  bool
6562                 AttachedAOID AOID
6563                 AnimParams   TileAnim
6564                 Glow         uint8
6565                 AOCollision  bool
6566                 NodeParam0   Content
6567                 NodeParam2   uint8
6568                 NodeTile     uint8
6569         }))(obj)).Pos {
6570                 for local163 := range ((*(*(struct {
6571                         Amount         uint16
6572                         Duration       float32
6573                         Pos, Vel, Acc  [2][3]float32
6574                         ExpirationTime [2]float32 // in seconds.
6575                         Size           [2]float32
6576                         Collide        bool
6577
6578                         //mt:len32
6579                         Texture
6580
6581                         ID           ParticleSpawnerID
6582                         Vertical     bool
6583                         CollisionRm  bool
6584                         AttachedAOID AOID
6585                         AnimParams   TileAnim
6586                         Glow         uint8
6587                         AOCollision  bool
6588                         NodeParam0   Content
6589                         NodeParam2   uint8
6590                         NodeTile     uint8
6591                 }))(obj)).Pos)[local162] {
6592                         {
6593                                 p := &(((*(*(struct {
6594                                         Amount         uint16
6595                                         Duration       float32
6596                                         Pos, Vel, Acc  [2][3]float32
6597                                         ExpirationTime [2]float32 // in seconds.
6598                                         Size           [2]float32
6599                                         Collide        bool
6600
6601                                         //mt:len32
6602                                         Texture
6603
6604                                         ID           ParticleSpawnerID
6605                                         Vertical     bool
6606                                         CollisionRm  bool
6607                                         AttachedAOID AOID
6608                                         AnimParams   TileAnim
6609                                         Glow         uint8
6610                                         AOCollision  bool
6611                                         NodeParam0   Content
6612                                         NodeParam2   uint8
6613                                         NodeTile     uint8
6614                                 }))(obj)).Pos)[local162])[local163]
6615                                 *p = math.Float32frombits(read32(r))
6616                         }
6617                 }
6618         }
6619         for local164 := range (*(*(struct {
6620                 Amount         uint16
6621                 Duration       float32
6622                 Pos, Vel, Acc  [2][3]float32
6623                 ExpirationTime [2]float32 // in seconds.
6624                 Size           [2]float32
6625                 Collide        bool
6626
6627                 //mt:len32
6628                 Texture
6629
6630                 ID           ParticleSpawnerID
6631                 Vertical     bool
6632                 CollisionRm  bool
6633                 AttachedAOID AOID
6634                 AnimParams   TileAnim
6635                 Glow         uint8
6636                 AOCollision  bool
6637                 NodeParam0   Content
6638                 NodeParam2   uint8
6639                 NodeTile     uint8
6640         }))(obj)).Vel {
6641                 for local165 := range ((*(*(struct {
6642                         Amount         uint16
6643                         Duration       float32
6644                         Pos, Vel, Acc  [2][3]float32
6645                         ExpirationTime [2]float32 // in seconds.
6646                         Size           [2]float32
6647                         Collide        bool
6648
6649                         //mt:len32
6650                         Texture
6651
6652                         ID           ParticleSpawnerID
6653                         Vertical     bool
6654                         CollisionRm  bool
6655                         AttachedAOID AOID
6656                         AnimParams   TileAnim
6657                         Glow         uint8
6658                         AOCollision  bool
6659                         NodeParam0   Content
6660                         NodeParam2   uint8
6661                         NodeTile     uint8
6662                 }))(obj)).Vel)[local164] {
6663                         {
6664                                 p := &(((*(*(struct {
6665                                         Amount         uint16
6666                                         Duration       float32
6667                                         Pos, Vel, Acc  [2][3]float32
6668                                         ExpirationTime [2]float32 // in seconds.
6669                                         Size           [2]float32
6670                                         Collide        bool
6671
6672                                         //mt:len32
6673                                         Texture
6674
6675                                         ID           ParticleSpawnerID
6676                                         Vertical     bool
6677                                         CollisionRm  bool
6678                                         AttachedAOID AOID
6679                                         AnimParams   TileAnim
6680                                         Glow         uint8
6681                                         AOCollision  bool
6682                                         NodeParam0   Content
6683                                         NodeParam2   uint8
6684                                         NodeTile     uint8
6685                                 }))(obj)).Vel)[local164])[local165]
6686                                 *p = math.Float32frombits(read32(r))
6687                         }
6688                 }
6689         }
6690         for local166 := range (*(*(struct {
6691                 Amount         uint16
6692                 Duration       float32
6693                 Pos, Vel, Acc  [2][3]float32
6694                 ExpirationTime [2]float32 // in seconds.
6695                 Size           [2]float32
6696                 Collide        bool
6697
6698                 //mt:len32
6699                 Texture
6700
6701                 ID           ParticleSpawnerID
6702                 Vertical     bool
6703                 CollisionRm  bool
6704                 AttachedAOID AOID
6705                 AnimParams   TileAnim
6706                 Glow         uint8
6707                 AOCollision  bool
6708                 NodeParam0   Content
6709                 NodeParam2   uint8
6710                 NodeTile     uint8
6711         }))(obj)).Acc {
6712                 for local167 := range ((*(*(struct {
6713                         Amount         uint16
6714                         Duration       float32
6715                         Pos, Vel, Acc  [2][3]float32
6716                         ExpirationTime [2]float32 // in seconds.
6717                         Size           [2]float32
6718                         Collide        bool
6719
6720                         //mt:len32
6721                         Texture
6722
6723                         ID           ParticleSpawnerID
6724                         Vertical     bool
6725                         CollisionRm  bool
6726                         AttachedAOID AOID
6727                         AnimParams   TileAnim
6728                         Glow         uint8
6729                         AOCollision  bool
6730                         NodeParam0   Content
6731                         NodeParam2   uint8
6732                         NodeTile     uint8
6733                 }))(obj)).Acc)[local166] {
6734                         {
6735                                 p := &(((*(*(struct {
6736                                         Amount         uint16
6737                                         Duration       float32
6738                                         Pos, Vel, Acc  [2][3]float32
6739                                         ExpirationTime [2]float32 // in seconds.
6740                                         Size           [2]float32
6741                                         Collide        bool
6742
6743                                         //mt:len32
6744                                         Texture
6745
6746                                         ID           ParticleSpawnerID
6747                                         Vertical     bool
6748                                         CollisionRm  bool
6749                                         AttachedAOID AOID
6750                                         AnimParams   TileAnim
6751                                         Glow         uint8
6752                                         AOCollision  bool
6753                                         NodeParam0   Content
6754                                         NodeParam2   uint8
6755                                         NodeTile     uint8
6756                                 }))(obj)).Acc)[local166])[local167]
6757                                 *p = math.Float32frombits(read32(r))
6758                         }
6759                 }
6760         }
6761         for local168 := range (*(*(struct {
6762                 Amount         uint16
6763                 Duration       float32
6764                 Pos, Vel, Acc  [2][3]float32
6765                 ExpirationTime [2]float32 // in seconds.
6766                 Size           [2]float32
6767                 Collide        bool
6768
6769                 //mt:len32
6770                 Texture
6771
6772                 ID           ParticleSpawnerID
6773                 Vertical     bool
6774                 CollisionRm  bool
6775                 AttachedAOID AOID
6776                 AnimParams   TileAnim
6777                 Glow         uint8
6778                 AOCollision  bool
6779                 NodeParam0   Content
6780                 NodeParam2   uint8
6781                 NodeTile     uint8
6782         }))(obj)).ExpirationTime {
6783                 {
6784                         p := &((*(*(struct {
6785                                 Amount         uint16
6786                                 Duration       float32
6787                                 Pos, Vel, Acc  [2][3]float32
6788                                 ExpirationTime [2]float32 // in seconds.
6789                                 Size           [2]float32
6790                                 Collide        bool
6791
6792                                 //mt:len32
6793                                 Texture
6794
6795                                 ID           ParticleSpawnerID
6796                                 Vertical     bool
6797                                 CollisionRm  bool
6798                                 AttachedAOID AOID
6799                                 AnimParams   TileAnim
6800                                 Glow         uint8
6801                                 AOCollision  bool
6802                                 NodeParam0   Content
6803                                 NodeParam2   uint8
6804                                 NodeTile     uint8
6805                         }))(obj)).ExpirationTime)[local168]
6806                         *p = math.Float32frombits(read32(r))
6807                 }
6808         }
6809         for local169 := range (*(*(struct {
6810                 Amount         uint16
6811                 Duration       float32
6812                 Pos, Vel, Acc  [2][3]float32
6813                 ExpirationTime [2]float32 // in seconds.
6814                 Size           [2]float32
6815                 Collide        bool
6816
6817                 //mt:len32
6818                 Texture
6819
6820                 ID           ParticleSpawnerID
6821                 Vertical     bool
6822                 CollisionRm  bool
6823                 AttachedAOID AOID
6824                 AnimParams   TileAnim
6825                 Glow         uint8
6826                 AOCollision  bool
6827                 NodeParam0   Content
6828                 NodeParam2   uint8
6829                 NodeTile     uint8
6830         }))(obj)).Size {
6831                 {
6832                         p := &((*(*(struct {
6833                                 Amount         uint16
6834                                 Duration       float32
6835                                 Pos, Vel, Acc  [2][3]float32
6836                                 ExpirationTime [2]float32 // in seconds.
6837                                 Size           [2]float32
6838                                 Collide        bool
6839
6840                                 //mt:len32
6841                                 Texture
6842
6843                                 ID           ParticleSpawnerID
6844                                 Vertical     bool
6845                                 CollisionRm  bool
6846                                 AttachedAOID AOID
6847                                 AnimParams   TileAnim
6848                                 Glow         uint8
6849                                 AOCollision  bool
6850                                 NodeParam0   Content
6851                                 NodeParam2   uint8
6852                                 NodeTile     uint8
6853                         }))(obj)).Size)[local169]
6854                         *p = math.Float32frombits(read32(r))
6855                 }
6856         }
6857         {
6858                 p := &(*(*(struct {
6859                         Amount         uint16
6860                         Duration       float32
6861                         Pos, Vel, Acc  [2][3]float32
6862                         ExpirationTime [2]float32 // in seconds.
6863                         Size           [2]float32
6864                         Collide        bool
6865
6866                         //mt:len32
6867                         Texture
6868
6869                         ID           ParticleSpawnerID
6870                         Vertical     bool
6871                         CollisionRm  bool
6872                         AttachedAOID AOID
6873                         AnimParams   TileAnim
6874                         Glow         uint8
6875                         AOCollision  bool
6876                         NodeParam0   Content
6877                         NodeParam2   uint8
6878                         NodeTile     uint8
6879                 }))(obj)).Collide
6880                 switch n := read8(r); n {
6881                 case 0:
6882                         *p = false
6883                 case 1:
6884                         *p = true
6885                 default:
6886                         chk(fmt.Errorf("invalid bool: %d", n))
6887                 }
6888         }
6889         var local170 []uint8
6890         var local171 uint32
6891         {
6892                 p := &local171
6893                 *p = read32(r)
6894         }
6895         (local170) = make([]uint8, local171)
6896         {
6897                 _, err := io.ReadFull(r, (local170)[:])
6898                 chk(err)
6899         }
6900         (*(*string)(&((*(*(struct {
6901                 Amount         uint16
6902                 Duration       float32
6903                 Pos, Vel, Acc  [2][3]float32
6904                 ExpirationTime [2]float32 // in seconds.
6905                 Size           [2]float32
6906                 Collide        bool
6907
6908                 //mt:len32
6909                 Texture
6910
6911                 ID           ParticleSpawnerID
6912                 Vertical     bool
6913                 CollisionRm  bool
6914                 AttachedAOID AOID
6915                 AnimParams   TileAnim
6916                 Glow         uint8
6917                 AOCollision  bool
6918                 NodeParam0   Content
6919                 NodeParam2   uint8
6920                 NodeTile     uint8
6921         }))(obj)).Texture))) = string(local170)
6922         if err := pcall(func() {
6923                 ((*(*(struct {
6924                         Amount         uint16
6925                         Duration       float32
6926                         Pos, Vel, Acc  [2][3]float32
6927                         ExpirationTime [2]float32 // in seconds.
6928                         Size           [2]float32
6929                         Collide        bool
6930
6931                         //mt:len32
6932                         Texture
6933
6934                         ID           ParticleSpawnerID
6935                         Vertical     bool
6936                         CollisionRm  bool
6937                         AttachedAOID AOID
6938                         AnimParams   TileAnim
6939                         Glow         uint8
6940                         AOCollision  bool
6941                         NodeParam0   Content
6942                         NodeParam2   uint8
6943                         NodeTile     uint8
6944                 }))(obj)).ID).deserialize(r)
6945         }); err != nil {
6946                 if err == io.EOF {
6947                         chk(io.EOF)
6948                 }
6949                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
6950         }
6951         {
6952                 p := &(*(*(struct {
6953                         Amount         uint16
6954                         Duration       float32
6955                         Pos, Vel, Acc  [2][3]float32
6956                         ExpirationTime [2]float32 // in seconds.
6957                         Size           [2]float32
6958                         Collide        bool
6959
6960                         //mt:len32
6961                         Texture
6962
6963                         ID           ParticleSpawnerID
6964                         Vertical     bool
6965                         CollisionRm  bool
6966                         AttachedAOID AOID
6967                         AnimParams   TileAnim
6968                         Glow         uint8
6969                         AOCollision  bool
6970                         NodeParam0   Content
6971                         NodeParam2   uint8
6972                         NodeTile     uint8
6973                 }))(obj)).Vertical
6974                 switch n := read8(r); n {
6975                 case 0:
6976                         *p = false
6977                 case 1:
6978                         *p = true
6979                 default:
6980                         chk(fmt.Errorf("invalid bool: %d", n))
6981                 }
6982         }
6983         {
6984                 p := &(*(*(struct {
6985                         Amount         uint16
6986                         Duration       float32
6987                         Pos, Vel, Acc  [2][3]float32
6988                         ExpirationTime [2]float32 // in seconds.
6989                         Size           [2]float32
6990                         Collide        bool
6991
6992                         //mt:len32
6993                         Texture
6994
6995                         ID           ParticleSpawnerID
6996                         Vertical     bool
6997                         CollisionRm  bool
6998                         AttachedAOID AOID
6999                         AnimParams   TileAnim
7000                         Glow         uint8
7001                         AOCollision  bool
7002                         NodeParam0   Content
7003                         NodeParam2   uint8
7004                         NodeTile     uint8
7005                 }))(obj)).CollisionRm
7006                 switch n := read8(r); n {
7007                 case 0:
7008                         *p = false
7009                 case 1:
7010                         *p = true
7011                 default:
7012                         chk(fmt.Errorf("invalid bool: %d", n))
7013                 }
7014         }
7015         if err := pcall(func() {
7016                 ((*(*(struct {
7017                         Amount         uint16
7018                         Duration       float32
7019                         Pos, Vel, Acc  [2][3]float32
7020                         ExpirationTime [2]float32 // in seconds.
7021                         Size           [2]float32
7022                         Collide        bool
7023
7024                         //mt:len32
7025                         Texture
7026
7027                         ID           ParticleSpawnerID
7028                         Vertical     bool
7029                         CollisionRm  bool
7030                         AttachedAOID AOID
7031                         AnimParams   TileAnim
7032                         Glow         uint8
7033                         AOCollision  bool
7034                         NodeParam0   Content
7035                         NodeParam2   uint8
7036                         NodeTile     uint8
7037                 }))(obj)).AttachedAOID).deserialize(r)
7038         }); err != nil {
7039                 if err == io.EOF {
7040                         chk(io.EOF)
7041                 }
7042                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
7043         }
7044         if err := pcall(func() {
7045                 ((*(*(struct {
7046                         Amount         uint16
7047                         Duration       float32
7048                         Pos, Vel, Acc  [2][3]float32
7049                         ExpirationTime [2]float32 // in seconds.
7050                         Size           [2]float32
7051                         Collide        bool
7052
7053                         //mt:len32
7054                         Texture
7055
7056                         ID           ParticleSpawnerID
7057                         Vertical     bool
7058                         CollisionRm  bool
7059                         AttachedAOID AOID
7060                         AnimParams   TileAnim
7061                         Glow         uint8
7062                         AOCollision  bool
7063                         NodeParam0   Content
7064                         NodeParam2   uint8
7065                         NodeTile     uint8
7066                 }))(obj)).AnimParams).deserialize(r)
7067         }); err != nil {
7068                 if err == io.EOF {
7069                         chk(io.EOF)
7070                 }
7071                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
7072         }
7073         {
7074                 p := &(*(*(struct {
7075                         Amount         uint16
7076                         Duration       float32
7077                         Pos, Vel, Acc  [2][3]float32
7078                         ExpirationTime [2]float32 // in seconds.
7079                         Size           [2]float32
7080                         Collide        bool
7081
7082                         //mt:len32
7083                         Texture
7084
7085                         ID           ParticleSpawnerID
7086                         Vertical     bool
7087                         CollisionRm  bool
7088                         AttachedAOID AOID
7089                         AnimParams   TileAnim
7090                         Glow         uint8
7091                         AOCollision  bool
7092                         NodeParam0   Content
7093                         NodeParam2   uint8
7094                         NodeTile     uint8
7095                 }))(obj)).Glow
7096                 *p = read8(r)
7097         }
7098         {
7099                 p := &(*(*(struct {
7100                         Amount         uint16
7101                         Duration       float32
7102                         Pos, Vel, Acc  [2][3]float32
7103                         ExpirationTime [2]float32 // in seconds.
7104                         Size           [2]float32
7105                         Collide        bool
7106
7107                         //mt:len32
7108                         Texture
7109
7110                         ID           ParticleSpawnerID
7111                         Vertical     bool
7112                         CollisionRm  bool
7113                         AttachedAOID AOID
7114                         AnimParams   TileAnim
7115                         Glow         uint8
7116                         AOCollision  bool
7117                         NodeParam0   Content
7118                         NodeParam2   uint8
7119                         NodeTile     uint8
7120                 }))(obj)).AOCollision
7121                 switch n := read8(r); n {
7122                 case 0:
7123                         *p = false
7124                 case 1:
7125                         *p = true
7126                 default:
7127                         chk(fmt.Errorf("invalid bool: %d", n))
7128                 }
7129         }
7130         if err := pcall(func() {
7131                 ((*(*(struct {
7132                         Amount         uint16
7133                         Duration       float32
7134                         Pos, Vel, Acc  [2][3]float32
7135                         ExpirationTime [2]float32 // in seconds.
7136                         Size           [2]float32
7137                         Collide        bool
7138
7139                         //mt:len32
7140                         Texture
7141
7142                         ID           ParticleSpawnerID
7143                         Vertical     bool
7144                         CollisionRm  bool
7145                         AttachedAOID AOID
7146                         AnimParams   TileAnim
7147                         Glow         uint8
7148                         AOCollision  bool
7149                         NodeParam0   Content
7150                         NodeParam2   uint8
7151                         NodeTile     uint8
7152                 }))(obj)).NodeParam0).deserialize(r)
7153         }); err != nil {
7154                 if err == io.EOF {
7155                         chk(io.EOF)
7156                 }
7157                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
7158         }
7159         {
7160                 p := &(*(*(struct {
7161                         Amount         uint16
7162                         Duration       float32
7163                         Pos, Vel, Acc  [2][3]float32
7164                         ExpirationTime [2]float32 // in seconds.
7165                         Size           [2]float32
7166                         Collide        bool
7167
7168                         //mt:len32
7169                         Texture
7170
7171                         ID           ParticleSpawnerID
7172                         Vertical     bool
7173                         CollisionRm  bool
7174                         AttachedAOID AOID
7175                         AnimParams   TileAnim
7176                         Glow         uint8
7177                         AOCollision  bool
7178                         NodeParam0   Content
7179                         NodeParam2   uint8
7180                         NodeTile     uint8
7181                 }))(obj)).NodeParam2
7182                 *p = read8(r)
7183         }
7184         {
7185                 p := &(*(*(struct {
7186                         Amount         uint16
7187                         Duration       float32
7188                         Pos, Vel, Acc  [2][3]float32
7189                         ExpirationTime [2]float32 // in seconds.
7190                         Size           [2]float32
7191                         Collide        bool
7192
7193                         //mt:len32
7194                         Texture
7195
7196                         ID           ParticleSpawnerID
7197                         Vertical     bool
7198                         CollisionRm  bool
7199                         AttachedAOID AOID
7200                         AnimParams   TileAnim
7201                         Glow         uint8
7202                         AOCollision  bool
7203                         NodeParam0   Content
7204                         NodeParam2   uint8
7205                         NodeTile     uint8
7206                 }))(obj)).NodeTile
7207                 *p = read8(r)
7208         }
7209 }
7210
7211 func (obj *ToCltAddHUD) serialize(w io.Writer) {
7212         if err := pcall(func() {
7213                 ((*(*(struct {
7214                         ID HUDID
7215                         HUD
7216                 }))(obj)).ID).serialize(w)
7217         }); err != nil {
7218                 if err == io.EOF {
7219                         chk(io.EOF)
7220                 }
7221                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7222         }
7223         if err := pcall(func() {
7224                 ((*(*(struct {
7225                         ID HUDID
7226                         HUD
7227                 }))(obj)).HUD).serialize(w)
7228         }); err != nil {
7229                 if err == io.EOF {
7230                         chk(io.EOF)
7231                 }
7232                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUD", err))
7233         }
7234 }
7235
7236 func (obj *ToCltAddHUD) deserialize(r io.Reader) {
7237         if err := pcall(func() {
7238                 ((*(*(struct {
7239                         ID HUDID
7240                         HUD
7241                 }))(obj)).ID).deserialize(r)
7242         }); err != nil {
7243                 if err == io.EOF {
7244                         chk(io.EOF)
7245                 }
7246                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7247         }
7248         if err := pcall(func() {
7249                 ((*(*(struct {
7250                         ID HUDID
7251                         HUD
7252                 }))(obj)).HUD).deserialize(r)
7253         }); err != nil {
7254                 if err == io.EOF {
7255                         chk(io.EOF)
7256                 }
7257                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUD", err))
7258         }
7259 }
7260
7261 func (obj *ToCltRmHUD) serialize(w io.Writer) {
7262         if err := pcall(func() {
7263                 ((*(*(struct {
7264                         ID HUDID
7265                 }))(obj)).ID).serialize(w)
7266         }); err != nil {
7267                 if err == io.EOF {
7268                         chk(io.EOF)
7269                 }
7270                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7271         }
7272 }
7273
7274 func (obj *ToCltRmHUD) deserialize(r io.Reader) {
7275         if err := pcall(func() {
7276                 ((*(*(struct {
7277                         ID HUDID
7278                 }))(obj)).ID).deserialize(r)
7279         }); err != nil {
7280                 if err == io.EOF {
7281                         chk(io.EOF)
7282                 }
7283                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7284         }
7285 }
7286
7287 func (obj *ToCltChangeHUD) serialize(w io.Writer) {
7288         if err := pcall(func() {
7289                 ((*(*(struct {
7290                         ID HUDID
7291
7292                         Field HUDField
7293
7294                         //mt:if %s.Field == HUDPos
7295                         Pos [2]float32
7296
7297                         //mt:if %s.Field == HUDName
7298                         Name string
7299
7300                         //mt:if %s.Field == HUDScale
7301                         Scale [2]float32
7302
7303                         //mt:if %s.Field == HUDText
7304                         Text string
7305
7306                         //mt:if %s.Field == HUDNumber
7307                         Number uint32
7308
7309                         //mt:if %s.Field == HUDItem
7310                         Item uint32
7311
7312                         //mt:if %s.Field == HUDDir
7313                         Dir uint32
7314
7315                         //mt:if %s.Field == HUDAlign
7316                         Align [2]float32
7317
7318                         //mt:if %s.Field == HUDOffset
7319                         Offset [2]float32
7320
7321                         //mt:if %s.Field == HUDWorldPos
7322                         WorldPos Pos
7323
7324                         //mt:if %s.Field == HUDSize
7325                         Size [2]int32
7326
7327                         //mt:if %s.Field == HUDZIndex
7328                         ZIndex int32
7329
7330                         //mt:if %s.Field == HUDText2
7331                         Text2 string
7332
7333                         //mt:if %s.Field == HUDStyle
7334                         Style HUDStyleFlags
7335                 }))(obj)).ID).serialize(w)
7336         }); err != nil {
7337                 if err == io.EOF {
7338                         chk(io.EOF)
7339                 }
7340                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7341         }
7342         if err := pcall(func() {
7343                 ((*(*(struct {
7344                         ID HUDID
7345
7346                         Field HUDField
7347
7348                         //mt:if %s.Field == HUDPos
7349                         Pos [2]float32
7350
7351                         //mt:if %s.Field == HUDName
7352                         Name string
7353
7354                         //mt:if %s.Field == HUDScale
7355                         Scale [2]float32
7356
7357                         //mt:if %s.Field == HUDText
7358                         Text string
7359
7360                         //mt:if %s.Field == HUDNumber
7361                         Number uint32
7362
7363                         //mt:if %s.Field == HUDItem
7364                         Item uint32
7365
7366                         //mt:if %s.Field == HUDDir
7367                         Dir uint32
7368
7369                         //mt:if %s.Field == HUDAlign
7370                         Align [2]float32
7371
7372                         //mt:if %s.Field == HUDOffset
7373                         Offset [2]float32
7374
7375                         //mt:if %s.Field == HUDWorldPos
7376                         WorldPos Pos
7377
7378                         //mt:if %s.Field == HUDSize
7379                         Size [2]int32
7380
7381                         //mt:if %s.Field == HUDZIndex
7382                         ZIndex int32
7383
7384                         //mt:if %s.Field == HUDText2
7385                         Text2 string
7386
7387                         //mt:if %s.Field == HUDStyle
7388                         Style HUDStyleFlags
7389                 }))(obj)).Field).serialize(w)
7390         }); err != nil {
7391                 if err == io.EOF {
7392                         chk(io.EOF)
7393                 }
7394                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDField", err))
7395         }
7396         if !((*(*(struct {
7397                 ID HUDID
7398
7399                 Field HUDField
7400
7401                 //mt:if %s.Field == HUDPos
7402                 Pos [2]float32
7403
7404                 //mt:if %s.Field == HUDName
7405                 Name string
7406
7407                 //mt:if %s.Field == HUDScale
7408                 Scale [2]float32
7409
7410                 //mt:if %s.Field == HUDText
7411                 Text string
7412
7413                 //mt:if %s.Field == HUDNumber
7414                 Number uint32
7415
7416                 //mt:if %s.Field == HUDItem
7417                 Item uint32
7418
7419                 //mt:if %s.Field == HUDDir
7420                 Dir uint32
7421
7422                 //mt:if %s.Field == HUDAlign
7423                 Align [2]float32
7424
7425                 //mt:if %s.Field == HUDOffset
7426                 Offset [2]float32
7427
7428                 //mt:if %s.Field == HUDWorldPos
7429                 WorldPos Pos
7430
7431                 //mt:if %s.Field == HUDSize
7432                 Size [2]int32
7433
7434                 //mt:if %s.Field == HUDZIndex
7435                 ZIndex int32
7436
7437                 //mt:if %s.Field == HUDText2
7438                 Text2 string
7439
7440                 //mt:if %s.Field == HUDStyle
7441                 Style HUDStyleFlags
7442         }))(obj)).Field < hudMax) {
7443                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7444         }
7445         if (*(*(struct {
7446                 ID HUDID
7447
7448                 Field HUDField
7449
7450                 //mt:if %s.Field == HUDPos
7451                 Pos [2]float32
7452
7453                 //mt:if %s.Field == HUDName
7454                 Name string
7455
7456                 //mt:if %s.Field == HUDScale
7457                 Scale [2]float32
7458
7459                 //mt:if %s.Field == HUDText
7460                 Text string
7461
7462                 //mt:if %s.Field == HUDNumber
7463                 Number uint32
7464
7465                 //mt:if %s.Field == HUDItem
7466                 Item uint32
7467
7468                 //mt:if %s.Field == HUDDir
7469                 Dir uint32
7470
7471                 //mt:if %s.Field == HUDAlign
7472                 Align [2]float32
7473
7474                 //mt:if %s.Field == HUDOffset
7475                 Offset [2]float32
7476
7477                 //mt:if %s.Field == HUDWorldPos
7478                 WorldPos Pos
7479
7480                 //mt:if %s.Field == HUDSize
7481                 Size [2]int32
7482
7483                 //mt:if %s.Field == HUDZIndex
7484                 ZIndex int32
7485
7486                 //mt:if %s.Field == HUDText2
7487                 Text2 string
7488
7489                 //mt:if %s.Field == HUDStyle
7490                 Style HUDStyleFlags
7491         }))(obj)).Field == HUDPos {
7492                 for local172 := range (*(*(struct {
7493                         ID HUDID
7494
7495                         Field HUDField
7496
7497                         //mt:if %s.Field == HUDPos
7498                         Pos [2]float32
7499
7500                         //mt:if %s.Field == HUDName
7501                         Name string
7502
7503                         //mt:if %s.Field == HUDScale
7504                         Scale [2]float32
7505
7506                         //mt:if %s.Field == HUDText
7507                         Text string
7508
7509                         //mt:if %s.Field == HUDNumber
7510                         Number uint32
7511
7512                         //mt:if %s.Field == HUDItem
7513                         Item uint32
7514
7515                         //mt:if %s.Field == HUDDir
7516                         Dir uint32
7517
7518                         //mt:if %s.Field == HUDAlign
7519                         Align [2]float32
7520
7521                         //mt:if %s.Field == HUDOffset
7522                         Offset [2]float32
7523
7524                         //mt:if %s.Field == HUDWorldPos
7525                         WorldPos Pos
7526
7527                         //mt:if %s.Field == HUDSize
7528                         Size [2]int32
7529
7530                         //mt:if %s.Field == HUDZIndex
7531                         ZIndex int32
7532
7533                         //mt:if %s.Field == HUDText2
7534                         Text2 string
7535
7536                         //mt:if %s.Field == HUDStyle
7537                         Style HUDStyleFlags
7538                 }))(obj)).Pos {
7539                         {
7540                                 x := ((*(*(struct {
7541                                         ID HUDID
7542
7543                                         Field HUDField
7544
7545                                         //mt:if %s.Field == HUDPos
7546                                         Pos [2]float32
7547
7548                                         //mt:if %s.Field == HUDName
7549                                         Name string
7550
7551                                         //mt:if %s.Field == HUDScale
7552                                         Scale [2]float32
7553
7554                                         //mt:if %s.Field == HUDText
7555                                         Text string
7556
7557                                         //mt:if %s.Field == HUDNumber
7558                                         Number uint32
7559
7560                                         //mt:if %s.Field == HUDItem
7561                                         Item uint32
7562
7563                                         //mt:if %s.Field == HUDDir
7564                                         Dir uint32
7565
7566                                         //mt:if %s.Field == HUDAlign
7567                                         Align [2]float32
7568
7569                                         //mt:if %s.Field == HUDOffset
7570                                         Offset [2]float32
7571
7572                                         //mt:if %s.Field == HUDWorldPos
7573                                         WorldPos Pos
7574
7575                                         //mt:if %s.Field == HUDSize
7576                                         Size [2]int32
7577
7578                                         //mt:if %s.Field == HUDZIndex
7579                                         ZIndex int32
7580
7581                                         //mt:if %s.Field == HUDText2
7582                                         Text2 string
7583
7584                                         //mt:if %s.Field == HUDStyle
7585                                         Style HUDStyleFlags
7586                                 }))(obj)).Pos)[local172]
7587                                 write32(w, math.Float32bits(x))
7588                         }
7589                 }
7590         }
7591         if (*(*(struct {
7592                 ID HUDID
7593
7594                 Field HUDField
7595
7596                 //mt:if %s.Field == HUDPos
7597                 Pos [2]float32
7598
7599                 //mt:if %s.Field == HUDName
7600                 Name string
7601
7602                 //mt:if %s.Field == HUDScale
7603                 Scale [2]float32
7604
7605                 //mt:if %s.Field == HUDText
7606                 Text string
7607
7608                 //mt:if %s.Field == HUDNumber
7609                 Number uint32
7610
7611                 //mt:if %s.Field == HUDItem
7612                 Item uint32
7613
7614                 //mt:if %s.Field == HUDDir
7615                 Dir uint32
7616
7617                 //mt:if %s.Field == HUDAlign
7618                 Align [2]float32
7619
7620                 //mt:if %s.Field == HUDOffset
7621                 Offset [2]float32
7622
7623                 //mt:if %s.Field == HUDWorldPos
7624                 WorldPos Pos
7625
7626                 //mt:if %s.Field == HUDSize
7627                 Size [2]int32
7628
7629                 //mt:if %s.Field == HUDZIndex
7630                 ZIndex int32
7631
7632                 //mt:if %s.Field == HUDText2
7633                 Text2 string
7634
7635                 //mt:if %s.Field == HUDStyle
7636                 Style HUDStyleFlags
7637         }))(obj)).Field == HUDName {
7638                 if len(([]byte((*(*(struct {
7639                         ID HUDID
7640
7641                         Field HUDField
7642
7643                         //mt:if %s.Field == HUDPos
7644                         Pos [2]float32
7645
7646                         //mt:if %s.Field == HUDName
7647                         Name string
7648
7649                         //mt:if %s.Field == HUDScale
7650                         Scale [2]float32
7651
7652                         //mt:if %s.Field == HUDText
7653                         Text string
7654
7655                         //mt:if %s.Field == HUDNumber
7656                         Number uint32
7657
7658                         //mt:if %s.Field == HUDItem
7659                         Item uint32
7660
7661                         //mt:if %s.Field == HUDDir
7662                         Dir uint32
7663
7664                         //mt:if %s.Field == HUDAlign
7665                         Align [2]float32
7666
7667                         //mt:if %s.Field == HUDOffset
7668                         Offset [2]float32
7669
7670                         //mt:if %s.Field == HUDWorldPos
7671                         WorldPos Pos
7672
7673                         //mt:if %s.Field == HUDSize
7674                         Size [2]int32
7675
7676                         //mt:if %s.Field == HUDZIndex
7677                         ZIndex int32
7678
7679                         //mt:if %s.Field == HUDText2
7680                         Text2 string
7681
7682                         //mt:if %s.Field == HUDStyle
7683                         Style HUDStyleFlags
7684                 }))(obj)).Name))) > math.MaxUint16 {
7685                         chk(ErrTooLong)
7686                 }
7687                 {
7688                         x := uint16(len(([]byte((*(*(struct {
7689                                 ID HUDID
7690
7691                                 Field HUDField
7692
7693                                 //mt:if %s.Field == HUDPos
7694                                 Pos [2]float32
7695
7696                                 //mt:if %s.Field == HUDName
7697                                 Name string
7698
7699                                 //mt:if %s.Field == HUDScale
7700                                 Scale [2]float32
7701
7702                                 //mt:if %s.Field == HUDText
7703                                 Text string
7704
7705                                 //mt:if %s.Field == HUDNumber
7706                                 Number uint32
7707
7708                                 //mt:if %s.Field == HUDItem
7709                                 Item uint32
7710
7711                                 //mt:if %s.Field == HUDDir
7712                                 Dir uint32
7713
7714                                 //mt:if %s.Field == HUDAlign
7715                                 Align [2]float32
7716
7717                                 //mt:if %s.Field == HUDOffset
7718                                 Offset [2]float32
7719
7720                                 //mt:if %s.Field == HUDWorldPos
7721                                 WorldPos Pos
7722
7723                                 //mt:if %s.Field == HUDSize
7724                                 Size [2]int32
7725
7726                                 //mt:if %s.Field == HUDZIndex
7727                                 ZIndex int32
7728
7729                                 //mt:if %s.Field == HUDText2
7730                                 Text2 string
7731
7732                                 //mt:if %s.Field == HUDStyle
7733                                 Style HUDStyleFlags
7734                         }))(obj)).Name))))
7735                         write16(w, uint16(x))
7736                 }
7737                 {
7738                         _, err := w.Write(([]byte((*(*(struct {
7739                                 ID HUDID
7740
7741                                 Field HUDField
7742
7743                                 //mt:if %s.Field == HUDPos
7744                                 Pos [2]float32
7745
7746                                 //mt:if %s.Field == HUDName
7747                                 Name string
7748
7749                                 //mt:if %s.Field == HUDScale
7750                                 Scale [2]float32
7751
7752                                 //mt:if %s.Field == HUDText
7753                                 Text string
7754
7755                                 //mt:if %s.Field == HUDNumber
7756                                 Number uint32
7757
7758                                 //mt:if %s.Field == HUDItem
7759                                 Item uint32
7760
7761                                 //mt:if %s.Field == HUDDir
7762                                 Dir uint32
7763
7764                                 //mt:if %s.Field == HUDAlign
7765                                 Align [2]float32
7766
7767                                 //mt:if %s.Field == HUDOffset
7768                                 Offset [2]float32
7769
7770                                 //mt:if %s.Field == HUDWorldPos
7771                                 WorldPos Pos
7772
7773                                 //mt:if %s.Field == HUDSize
7774                                 Size [2]int32
7775
7776                                 //mt:if %s.Field == HUDZIndex
7777                                 ZIndex int32
7778
7779                                 //mt:if %s.Field == HUDText2
7780                                 Text2 string
7781
7782                                 //mt:if %s.Field == HUDStyle
7783                                 Style HUDStyleFlags
7784                         }))(obj)).Name))[:])
7785                         chk(err)
7786                 }
7787         }
7788         if (*(*(struct {
7789                 ID HUDID
7790
7791                 Field HUDField
7792
7793                 //mt:if %s.Field == HUDPos
7794                 Pos [2]float32
7795
7796                 //mt:if %s.Field == HUDName
7797                 Name string
7798
7799                 //mt:if %s.Field == HUDScale
7800                 Scale [2]float32
7801
7802                 //mt:if %s.Field == HUDText
7803                 Text string
7804
7805                 //mt:if %s.Field == HUDNumber
7806                 Number uint32
7807
7808                 //mt:if %s.Field == HUDItem
7809                 Item uint32
7810
7811                 //mt:if %s.Field == HUDDir
7812                 Dir uint32
7813
7814                 //mt:if %s.Field == HUDAlign
7815                 Align [2]float32
7816
7817                 //mt:if %s.Field == HUDOffset
7818                 Offset [2]float32
7819
7820                 //mt:if %s.Field == HUDWorldPos
7821                 WorldPos Pos
7822
7823                 //mt:if %s.Field == HUDSize
7824                 Size [2]int32
7825
7826                 //mt:if %s.Field == HUDZIndex
7827                 ZIndex int32
7828
7829                 //mt:if %s.Field == HUDText2
7830                 Text2 string
7831
7832                 //mt:if %s.Field == HUDStyle
7833                 Style HUDStyleFlags
7834         }))(obj)).Field == HUDScale {
7835                 for local173 := range (*(*(struct {
7836                         ID HUDID
7837
7838                         Field HUDField
7839
7840                         //mt:if %s.Field == HUDPos
7841                         Pos [2]float32
7842
7843                         //mt:if %s.Field == HUDName
7844                         Name string
7845
7846                         //mt:if %s.Field == HUDScale
7847                         Scale [2]float32
7848
7849                         //mt:if %s.Field == HUDText
7850                         Text string
7851
7852                         //mt:if %s.Field == HUDNumber
7853                         Number uint32
7854
7855                         //mt:if %s.Field == HUDItem
7856                         Item uint32
7857
7858                         //mt:if %s.Field == HUDDir
7859                         Dir uint32
7860
7861                         //mt:if %s.Field == HUDAlign
7862                         Align [2]float32
7863
7864                         //mt:if %s.Field == HUDOffset
7865                         Offset [2]float32
7866
7867                         //mt:if %s.Field == HUDWorldPos
7868                         WorldPos Pos
7869
7870                         //mt:if %s.Field == HUDSize
7871                         Size [2]int32
7872
7873                         //mt:if %s.Field == HUDZIndex
7874                         ZIndex int32
7875
7876                         //mt:if %s.Field == HUDText2
7877                         Text2 string
7878
7879                         //mt:if %s.Field == HUDStyle
7880                         Style HUDStyleFlags
7881                 }))(obj)).Scale {
7882                         {
7883                                 x := ((*(*(struct {
7884                                         ID HUDID
7885
7886                                         Field HUDField
7887
7888                                         //mt:if %s.Field == HUDPos
7889                                         Pos [2]float32
7890
7891                                         //mt:if %s.Field == HUDName
7892                                         Name string
7893
7894                                         //mt:if %s.Field == HUDScale
7895                                         Scale [2]float32
7896
7897                                         //mt:if %s.Field == HUDText
7898                                         Text string
7899
7900                                         //mt:if %s.Field == HUDNumber
7901                                         Number uint32
7902
7903                                         //mt:if %s.Field == HUDItem
7904                                         Item uint32
7905
7906                                         //mt:if %s.Field == HUDDir
7907                                         Dir uint32
7908
7909                                         //mt:if %s.Field == HUDAlign
7910                                         Align [2]float32
7911
7912                                         //mt:if %s.Field == HUDOffset
7913                                         Offset [2]float32
7914
7915                                         //mt:if %s.Field == HUDWorldPos
7916                                         WorldPos Pos
7917
7918                                         //mt:if %s.Field == HUDSize
7919                                         Size [2]int32
7920
7921                                         //mt:if %s.Field == HUDZIndex
7922                                         ZIndex int32
7923
7924                                         //mt:if %s.Field == HUDText2
7925                                         Text2 string
7926
7927                                         //mt:if %s.Field == HUDStyle
7928                                         Style HUDStyleFlags
7929                                 }))(obj)).Scale)[local173]
7930                                 write32(w, math.Float32bits(x))
7931                         }
7932                 }
7933         }
7934         if (*(*(struct {
7935                 ID HUDID
7936
7937                 Field HUDField
7938
7939                 //mt:if %s.Field == HUDPos
7940                 Pos [2]float32
7941
7942                 //mt:if %s.Field == HUDName
7943                 Name string
7944
7945                 //mt:if %s.Field == HUDScale
7946                 Scale [2]float32
7947
7948                 //mt:if %s.Field == HUDText
7949                 Text string
7950
7951                 //mt:if %s.Field == HUDNumber
7952                 Number uint32
7953
7954                 //mt:if %s.Field == HUDItem
7955                 Item uint32
7956
7957                 //mt:if %s.Field == HUDDir
7958                 Dir uint32
7959
7960                 //mt:if %s.Field == HUDAlign
7961                 Align [2]float32
7962
7963                 //mt:if %s.Field == HUDOffset
7964                 Offset [2]float32
7965
7966                 //mt:if %s.Field == HUDWorldPos
7967                 WorldPos Pos
7968
7969                 //mt:if %s.Field == HUDSize
7970                 Size [2]int32
7971
7972                 //mt:if %s.Field == HUDZIndex
7973                 ZIndex int32
7974
7975                 //mt:if %s.Field == HUDText2
7976                 Text2 string
7977
7978                 //mt:if %s.Field == HUDStyle
7979                 Style HUDStyleFlags
7980         }))(obj)).Field == HUDText {
7981                 if len(([]byte((*(*(struct {
7982                         ID HUDID
7983
7984                         Field HUDField
7985
7986                         //mt:if %s.Field == HUDPos
7987                         Pos [2]float32
7988
7989                         //mt:if %s.Field == HUDName
7990                         Name string
7991
7992                         //mt:if %s.Field == HUDScale
7993                         Scale [2]float32
7994
7995                         //mt:if %s.Field == HUDText
7996                         Text string
7997
7998                         //mt:if %s.Field == HUDNumber
7999                         Number uint32
8000
8001                         //mt:if %s.Field == HUDItem
8002                         Item uint32
8003
8004                         //mt:if %s.Field == HUDDir
8005                         Dir uint32
8006
8007                         //mt:if %s.Field == HUDAlign
8008                         Align [2]float32
8009
8010                         //mt:if %s.Field == HUDOffset
8011                         Offset [2]float32
8012
8013                         //mt:if %s.Field == HUDWorldPos
8014                         WorldPos Pos
8015
8016                         //mt:if %s.Field == HUDSize
8017                         Size [2]int32
8018
8019                         //mt:if %s.Field == HUDZIndex
8020                         ZIndex int32
8021
8022                         //mt:if %s.Field == HUDText2
8023                         Text2 string
8024
8025                         //mt:if %s.Field == HUDStyle
8026                         Style HUDStyleFlags
8027                 }))(obj)).Text))) > math.MaxUint16 {
8028                         chk(ErrTooLong)
8029                 }
8030                 {
8031                         x := uint16(len(([]byte((*(*(struct {
8032                                 ID HUDID
8033
8034                                 Field HUDField
8035
8036                                 //mt:if %s.Field == HUDPos
8037                                 Pos [2]float32
8038
8039                                 //mt:if %s.Field == HUDName
8040                                 Name string
8041
8042                                 //mt:if %s.Field == HUDScale
8043                                 Scale [2]float32
8044
8045                                 //mt:if %s.Field == HUDText
8046                                 Text string
8047
8048                                 //mt:if %s.Field == HUDNumber
8049                                 Number uint32
8050
8051                                 //mt:if %s.Field == HUDItem
8052                                 Item uint32
8053
8054                                 //mt:if %s.Field == HUDDir
8055                                 Dir uint32
8056
8057                                 //mt:if %s.Field == HUDAlign
8058                                 Align [2]float32
8059
8060                                 //mt:if %s.Field == HUDOffset
8061                                 Offset [2]float32
8062
8063                                 //mt:if %s.Field == HUDWorldPos
8064                                 WorldPos Pos
8065
8066                                 //mt:if %s.Field == HUDSize
8067                                 Size [2]int32
8068
8069                                 //mt:if %s.Field == HUDZIndex
8070                                 ZIndex int32
8071
8072                                 //mt:if %s.Field == HUDText2
8073                                 Text2 string
8074
8075                                 //mt:if %s.Field == HUDStyle
8076                                 Style HUDStyleFlags
8077                         }))(obj)).Text))))
8078                         write16(w, uint16(x))
8079                 }
8080                 {
8081                         _, err := w.Write(([]byte((*(*(struct {
8082                                 ID HUDID
8083
8084                                 Field HUDField
8085
8086                                 //mt:if %s.Field == HUDPos
8087                                 Pos [2]float32
8088
8089                                 //mt:if %s.Field == HUDName
8090                                 Name string
8091
8092                                 //mt:if %s.Field == HUDScale
8093                                 Scale [2]float32
8094
8095                                 //mt:if %s.Field == HUDText
8096                                 Text string
8097
8098                                 //mt:if %s.Field == HUDNumber
8099                                 Number uint32
8100
8101                                 //mt:if %s.Field == HUDItem
8102                                 Item uint32
8103
8104                                 //mt:if %s.Field == HUDDir
8105                                 Dir uint32
8106
8107                                 //mt:if %s.Field == HUDAlign
8108                                 Align [2]float32
8109
8110                                 //mt:if %s.Field == HUDOffset
8111                                 Offset [2]float32
8112
8113                                 //mt:if %s.Field == HUDWorldPos
8114                                 WorldPos Pos
8115
8116                                 //mt:if %s.Field == HUDSize
8117                                 Size [2]int32
8118
8119                                 //mt:if %s.Field == HUDZIndex
8120                                 ZIndex int32
8121
8122                                 //mt:if %s.Field == HUDText2
8123                                 Text2 string
8124
8125                                 //mt:if %s.Field == HUDStyle
8126                                 Style HUDStyleFlags
8127                         }))(obj)).Text))[:])
8128                         chk(err)
8129                 }
8130         }
8131         if (*(*(struct {
8132                 ID HUDID
8133
8134                 Field HUDField
8135
8136                 //mt:if %s.Field == HUDPos
8137                 Pos [2]float32
8138
8139                 //mt:if %s.Field == HUDName
8140                 Name string
8141
8142                 //mt:if %s.Field == HUDScale
8143                 Scale [2]float32
8144
8145                 //mt:if %s.Field == HUDText
8146                 Text string
8147
8148                 //mt:if %s.Field == HUDNumber
8149                 Number uint32
8150
8151                 //mt:if %s.Field == HUDItem
8152                 Item uint32
8153
8154                 //mt:if %s.Field == HUDDir
8155                 Dir uint32
8156
8157                 //mt:if %s.Field == HUDAlign
8158                 Align [2]float32
8159
8160                 //mt:if %s.Field == HUDOffset
8161                 Offset [2]float32
8162
8163                 //mt:if %s.Field == HUDWorldPos
8164                 WorldPos Pos
8165
8166                 //mt:if %s.Field == HUDSize
8167                 Size [2]int32
8168
8169                 //mt:if %s.Field == HUDZIndex
8170                 ZIndex int32
8171
8172                 //mt:if %s.Field == HUDText2
8173                 Text2 string
8174
8175                 //mt:if %s.Field == HUDStyle
8176                 Style HUDStyleFlags
8177         }))(obj)).Field == HUDNumber {
8178                 {
8179                         x := (*(*(struct {
8180                                 ID HUDID
8181
8182                                 Field HUDField
8183
8184                                 //mt:if %s.Field == HUDPos
8185                                 Pos [2]float32
8186
8187                                 //mt:if %s.Field == HUDName
8188                                 Name string
8189
8190                                 //mt:if %s.Field == HUDScale
8191                                 Scale [2]float32
8192
8193                                 //mt:if %s.Field == HUDText
8194                                 Text string
8195
8196                                 //mt:if %s.Field == HUDNumber
8197                                 Number uint32
8198
8199                                 //mt:if %s.Field == HUDItem
8200                                 Item uint32
8201
8202                                 //mt:if %s.Field == HUDDir
8203                                 Dir uint32
8204
8205                                 //mt:if %s.Field == HUDAlign
8206                                 Align [2]float32
8207
8208                                 //mt:if %s.Field == HUDOffset
8209                                 Offset [2]float32
8210
8211                                 //mt:if %s.Field == HUDWorldPos
8212                                 WorldPos Pos
8213
8214                                 //mt:if %s.Field == HUDSize
8215                                 Size [2]int32
8216
8217                                 //mt:if %s.Field == HUDZIndex
8218                                 ZIndex int32
8219
8220                                 //mt:if %s.Field == HUDText2
8221                                 Text2 string
8222
8223                                 //mt:if %s.Field == HUDStyle
8224                                 Style HUDStyleFlags
8225                         }))(obj)).Number
8226                         write32(w, uint32(x))
8227                 }
8228         }
8229         if (*(*(struct {
8230                 ID HUDID
8231
8232                 Field HUDField
8233
8234                 //mt:if %s.Field == HUDPos
8235                 Pos [2]float32
8236
8237                 //mt:if %s.Field == HUDName
8238                 Name string
8239
8240                 //mt:if %s.Field == HUDScale
8241                 Scale [2]float32
8242
8243                 //mt:if %s.Field == HUDText
8244                 Text string
8245
8246                 //mt:if %s.Field == HUDNumber
8247                 Number uint32
8248
8249                 //mt:if %s.Field == HUDItem
8250                 Item uint32
8251
8252                 //mt:if %s.Field == HUDDir
8253                 Dir uint32
8254
8255                 //mt:if %s.Field == HUDAlign
8256                 Align [2]float32
8257
8258                 //mt:if %s.Field == HUDOffset
8259                 Offset [2]float32
8260
8261                 //mt:if %s.Field == HUDWorldPos
8262                 WorldPos Pos
8263
8264                 //mt:if %s.Field == HUDSize
8265                 Size [2]int32
8266
8267                 //mt:if %s.Field == HUDZIndex
8268                 ZIndex int32
8269
8270                 //mt:if %s.Field == HUDText2
8271                 Text2 string
8272
8273                 //mt:if %s.Field == HUDStyle
8274                 Style HUDStyleFlags
8275         }))(obj)).Field == HUDItem {
8276                 {
8277                         x := (*(*(struct {
8278                                 ID HUDID
8279
8280                                 Field HUDField
8281
8282                                 //mt:if %s.Field == HUDPos
8283                                 Pos [2]float32
8284
8285                                 //mt:if %s.Field == HUDName
8286                                 Name string
8287
8288                                 //mt:if %s.Field == HUDScale
8289                                 Scale [2]float32
8290
8291                                 //mt:if %s.Field == HUDText
8292                                 Text string
8293
8294                                 //mt:if %s.Field == HUDNumber
8295                                 Number uint32
8296
8297                                 //mt:if %s.Field == HUDItem
8298                                 Item uint32
8299
8300                                 //mt:if %s.Field == HUDDir
8301                                 Dir uint32
8302
8303                                 //mt:if %s.Field == HUDAlign
8304                                 Align [2]float32
8305
8306                                 //mt:if %s.Field == HUDOffset
8307                                 Offset [2]float32
8308
8309                                 //mt:if %s.Field == HUDWorldPos
8310                                 WorldPos Pos
8311
8312                                 //mt:if %s.Field == HUDSize
8313                                 Size [2]int32
8314
8315                                 //mt:if %s.Field == HUDZIndex
8316                                 ZIndex int32
8317
8318                                 //mt:if %s.Field == HUDText2
8319                                 Text2 string
8320
8321                                 //mt:if %s.Field == HUDStyle
8322                                 Style HUDStyleFlags
8323                         }))(obj)).Item
8324                         write32(w, uint32(x))
8325                 }
8326         }
8327         if (*(*(struct {
8328                 ID HUDID
8329
8330                 Field HUDField
8331
8332                 //mt:if %s.Field == HUDPos
8333                 Pos [2]float32
8334
8335                 //mt:if %s.Field == HUDName
8336                 Name string
8337
8338                 //mt:if %s.Field == HUDScale
8339                 Scale [2]float32
8340
8341                 //mt:if %s.Field == HUDText
8342                 Text string
8343
8344                 //mt:if %s.Field == HUDNumber
8345                 Number uint32
8346
8347                 //mt:if %s.Field == HUDItem
8348                 Item uint32
8349
8350                 //mt:if %s.Field == HUDDir
8351                 Dir uint32
8352
8353                 //mt:if %s.Field == HUDAlign
8354                 Align [2]float32
8355
8356                 //mt:if %s.Field == HUDOffset
8357                 Offset [2]float32
8358
8359                 //mt:if %s.Field == HUDWorldPos
8360                 WorldPos Pos
8361
8362                 //mt:if %s.Field == HUDSize
8363                 Size [2]int32
8364
8365                 //mt:if %s.Field == HUDZIndex
8366                 ZIndex int32
8367
8368                 //mt:if %s.Field == HUDText2
8369                 Text2 string
8370
8371                 //mt:if %s.Field == HUDStyle
8372                 Style HUDStyleFlags
8373         }))(obj)).Field == HUDDir {
8374                 {
8375                         x := (*(*(struct {
8376                                 ID HUDID
8377
8378                                 Field HUDField
8379
8380                                 //mt:if %s.Field == HUDPos
8381                                 Pos [2]float32
8382
8383                                 //mt:if %s.Field == HUDName
8384                                 Name string
8385
8386                                 //mt:if %s.Field == HUDScale
8387                                 Scale [2]float32
8388
8389                                 //mt:if %s.Field == HUDText
8390                                 Text string
8391
8392                                 //mt:if %s.Field == HUDNumber
8393                                 Number uint32
8394
8395                                 //mt:if %s.Field == HUDItem
8396                                 Item uint32
8397
8398                                 //mt:if %s.Field == HUDDir
8399                                 Dir uint32
8400
8401                                 //mt:if %s.Field == HUDAlign
8402                                 Align [2]float32
8403
8404                                 //mt:if %s.Field == HUDOffset
8405                                 Offset [2]float32
8406
8407                                 //mt:if %s.Field == HUDWorldPos
8408                                 WorldPos Pos
8409
8410                                 //mt:if %s.Field == HUDSize
8411                                 Size [2]int32
8412
8413                                 //mt:if %s.Field == HUDZIndex
8414                                 ZIndex int32
8415
8416                                 //mt:if %s.Field == HUDText2
8417                                 Text2 string
8418
8419                                 //mt:if %s.Field == HUDStyle
8420                                 Style HUDStyleFlags
8421                         }))(obj)).Dir
8422                         write32(w, uint32(x))
8423                 }
8424         }
8425         if (*(*(struct {
8426                 ID HUDID
8427
8428                 Field HUDField
8429
8430                 //mt:if %s.Field == HUDPos
8431                 Pos [2]float32
8432
8433                 //mt:if %s.Field == HUDName
8434                 Name string
8435
8436                 //mt:if %s.Field == HUDScale
8437                 Scale [2]float32
8438
8439                 //mt:if %s.Field == HUDText
8440                 Text string
8441
8442                 //mt:if %s.Field == HUDNumber
8443                 Number uint32
8444
8445                 //mt:if %s.Field == HUDItem
8446                 Item uint32
8447
8448                 //mt:if %s.Field == HUDDir
8449                 Dir uint32
8450
8451                 //mt:if %s.Field == HUDAlign
8452                 Align [2]float32
8453
8454                 //mt:if %s.Field == HUDOffset
8455                 Offset [2]float32
8456
8457                 //mt:if %s.Field == HUDWorldPos
8458                 WorldPos Pos
8459
8460                 //mt:if %s.Field == HUDSize
8461                 Size [2]int32
8462
8463                 //mt:if %s.Field == HUDZIndex
8464                 ZIndex int32
8465
8466                 //mt:if %s.Field == HUDText2
8467                 Text2 string
8468
8469                 //mt:if %s.Field == HUDStyle
8470                 Style HUDStyleFlags
8471         }))(obj)).Field == HUDAlign {
8472                 for local174 := range (*(*(struct {
8473                         ID HUDID
8474
8475                         Field HUDField
8476
8477                         //mt:if %s.Field == HUDPos
8478                         Pos [2]float32
8479
8480                         //mt:if %s.Field == HUDName
8481                         Name string
8482
8483                         //mt:if %s.Field == HUDScale
8484                         Scale [2]float32
8485
8486                         //mt:if %s.Field == HUDText
8487                         Text string
8488
8489                         //mt:if %s.Field == HUDNumber
8490                         Number uint32
8491
8492                         //mt:if %s.Field == HUDItem
8493                         Item uint32
8494
8495                         //mt:if %s.Field == HUDDir
8496                         Dir uint32
8497
8498                         //mt:if %s.Field == HUDAlign
8499                         Align [2]float32
8500
8501                         //mt:if %s.Field == HUDOffset
8502                         Offset [2]float32
8503
8504                         //mt:if %s.Field == HUDWorldPos
8505                         WorldPos Pos
8506
8507                         //mt:if %s.Field == HUDSize
8508                         Size [2]int32
8509
8510                         //mt:if %s.Field == HUDZIndex
8511                         ZIndex int32
8512
8513                         //mt:if %s.Field == HUDText2
8514                         Text2 string
8515
8516                         //mt:if %s.Field == HUDStyle
8517                         Style HUDStyleFlags
8518                 }))(obj)).Align {
8519                         {
8520                                 x := ((*(*(struct {
8521                                         ID HUDID
8522
8523                                         Field HUDField
8524
8525                                         //mt:if %s.Field == HUDPos
8526                                         Pos [2]float32
8527
8528                                         //mt:if %s.Field == HUDName
8529                                         Name string
8530
8531                                         //mt:if %s.Field == HUDScale
8532                                         Scale [2]float32
8533
8534                                         //mt:if %s.Field == HUDText
8535                                         Text string
8536
8537                                         //mt:if %s.Field == HUDNumber
8538                                         Number uint32
8539
8540                                         //mt:if %s.Field == HUDItem
8541                                         Item uint32
8542
8543                                         //mt:if %s.Field == HUDDir
8544                                         Dir uint32
8545
8546                                         //mt:if %s.Field == HUDAlign
8547                                         Align [2]float32
8548
8549                                         //mt:if %s.Field == HUDOffset
8550                                         Offset [2]float32
8551
8552                                         //mt:if %s.Field == HUDWorldPos
8553                                         WorldPos Pos
8554
8555                                         //mt:if %s.Field == HUDSize
8556                                         Size [2]int32
8557
8558                                         //mt:if %s.Field == HUDZIndex
8559                                         ZIndex int32
8560
8561                                         //mt:if %s.Field == HUDText2
8562                                         Text2 string
8563
8564                                         //mt:if %s.Field == HUDStyle
8565                                         Style HUDStyleFlags
8566                                 }))(obj)).Align)[local174]
8567                                 write32(w, math.Float32bits(x))
8568                         }
8569                 }
8570         }
8571         if (*(*(struct {
8572                 ID HUDID
8573
8574                 Field HUDField
8575
8576                 //mt:if %s.Field == HUDPos
8577                 Pos [2]float32
8578
8579                 //mt:if %s.Field == HUDName
8580                 Name string
8581
8582                 //mt:if %s.Field == HUDScale
8583                 Scale [2]float32
8584
8585                 //mt:if %s.Field == HUDText
8586                 Text string
8587
8588                 //mt:if %s.Field == HUDNumber
8589                 Number uint32
8590
8591                 //mt:if %s.Field == HUDItem
8592                 Item uint32
8593
8594                 //mt:if %s.Field == HUDDir
8595                 Dir uint32
8596
8597                 //mt:if %s.Field == HUDAlign
8598                 Align [2]float32
8599
8600                 //mt:if %s.Field == HUDOffset
8601                 Offset [2]float32
8602
8603                 //mt:if %s.Field == HUDWorldPos
8604                 WorldPos Pos
8605
8606                 //mt:if %s.Field == HUDSize
8607                 Size [2]int32
8608
8609                 //mt:if %s.Field == HUDZIndex
8610                 ZIndex int32
8611
8612                 //mt:if %s.Field == HUDText2
8613                 Text2 string
8614
8615                 //mt:if %s.Field == HUDStyle
8616                 Style HUDStyleFlags
8617         }))(obj)).Field == HUDOffset {
8618                 for local175 := range (*(*(struct {
8619                         ID HUDID
8620
8621                         Field HUDField
8622
8623                         //mt:if %s.Field == HUDPos
8624                         Pos [2]float32
8625
8626                         //mt:if %s.Field == HUDName
8627                         Name string
8628
8629                         //mt:if %s.Field == HUDScale
8630                         Scale [2]float32
8631
8632                         //mt:if %s.Field == HUDText
8633                         Text string
8634
8635                         //mt:if %s.Field == HUDNumber
8636                         Number uint32
8637
8638                         //mt:if %s.Field == HUDItem
8639                         Item uint32
8640
8641                         //mt:if %s.Field == HUDDir
8642                         Dir uint32
8643
8644                         //mt:if %s.Field == HUDAlign
8645                         Align [2]float32
8646
8647                         //mt:if %s.Field == HUDOffset
8648                         Offset [2]float32
8649
8650                         //mt:if %s.Field == HUDWorldPos
8651                         WorldPos Pos
8652
8653                         //mt:if %s.Field == HUDSize
8654                         Size [2]int32
8655
8656                         //mt:if %s.Field == HUDZIndex
8657                         ZIndex int32
8658
8659                         //mt:if %s.Field == HUDText2
8660                         Text2 string
8661
8662                         //mt:if %s.Field == HUDStyle
8663                         Style HUDStyleFlags
8664                 }))(obj)).Offset {
8665                         {
8666                                 x := ((*(*(struct {
8667                                         ID HUDID
8668
8669                                         Field HUDField
8670
8671                                         //mt:if %s.Field == HUDPos
8672                                         Pos [2]float32
8673
8674                                         //mt:if %s.Field == HUDName
8675                                         Name string
8676
8677                                         //mt:if %s.Field == HUDScale
8678                                         Scale [2]float32
8679
8680                                         //mt:if %s.Field == HUDText
8681                                         Text string
8682
8683                                         //mt:if %s.Field == HUDNumber
8684                                         Number uint32
8685
8686                                         //mt:if %s.Field == HUDItem
8687                                         Item uint32
8688
8689                                         //mt:if %s.Field == HUDDir
8690                                         Dir uint32
8691
8692                                         //mt:if %s.Field == HUDAlign
8693                                         Align [2]float32
8694
8695                                         //mt:if %s.Field == HUDOffset
8696                                         Offset [2]float32
8697
8698                                         //mt:if %s.Field == HUDWorldPos
8699                                         WorldPos Pos
8700
8701                                         //mt:if %s.Field == HUDSize
8702                                         Size [2]int32
8703
8704                                         //mt:if %s.Field == HUDZIndex
8705                                         ZIndex int32
8706
8707                                         //mt:if %s.Field == HUDText2
8708                                         Text2 string
8709
8710                                         //mt:if %s.Field == HUDStyle
8711                                         Style HUDStyleFlags
8712                                 }))(obj)).Offset)[local175]
8713                                 write32(w, math.Float32bits(x))
8714                         }
8715                 }
8716         }
8717         if (*(*(struct {
8718                 ID HUDID
8719
8720                 Field HUDField
8721
8722                 //mt:if %s.Field == HUDPos
8723                 Pos [2]float32
8724
8725                 //mt:if %s.Field == HUDName
8726                 Name string
8727
8728                 //mt:if %s.Field == HUDScale
8729                 Scale [2]float32
8730
8731                 //mt:if %s.Field == HUDText
8732                 Text string
8733
8734                 //mt:if %s.Field == HUDNumber
8735                 Number uint32
8736
8737                 //mt:if %s.Field == HUDItem
8738                 Item uint32
8739
8740                 //mt:if %s.Field == HUDDir
8741                 Dir uint32
8742
8743                 //mt:if %s.Field == HUDAlign
8744                 Align [2]float32
8745
8746                 //mt:if %s.Field == HUDOffset
8747                 Offset [2]float32
8748
8749                 //mt:if %s.Field == HUDWorldPos
8750                 WorldPos Pos
8751
8752                 //mt:if %s.Field == HUDSize
8753                 Size [2]int32
8754
8755                 //mt:if %s.Field == HUDZIndex
8756                 ZIndex int32
8757
8758                 //mt:if %s.Field == HUDText2
8759                 Text2 string
8760
8761                 //mt:if %s.Field == HUDStyle
8762                 Style HUDStyleFlags
8763         }))(obj)).Field == HUDWorldPos {
8764                 if err := pcall(func() {
8765                         ((*(*(struct {
8766                                 ID HUDID
8767
8768                                 Field HUDField
8769
8770                                 //mt:if %s.Field == HUDPos
8771                                 Pos [2]float32
8772
8773                                 //mt:if %s.Field == HUDName
8774                                 Name string
8775
8776                                 //mt:if %s.Field == HUDScale
8777                                 Scale [2]float32
8778
8779                                 //mt:if %s.Field == HUDText
8780                                 Text string
8781
8782                                 //mt:if %s.Field == HUDNumber
8783                                 Number uint32
8784
8785                                 //mt:if %s.Field == HUDItem
8786                                 Item uint32
8787
8788                                 //mt:if %s.Field == HUDDir
8789                                 Dir uint32
8790
8791                                 //mt:if %s.Field == HUDAlign
8792                                 Align [2]float32
8793
8794                                 //mt:if %s.Field == HUDOffset
8795                                 Offset [2]float32
8796
8797                                 //mt:if %s.Field == HUDWorldPos
8798                                 WorldPos Pos
8799
8800                                 //mt:if %s.Field == HUDSize
8801                                 Size [2]int32
8802
8803                                 //mt:if %s.Field == HUDZIndex
8804                                 ZIndex int32
8805
8806                                 //mt:if %s.Field == HUDText2
8807                                 Text2 string
8808
8809                                 //mt:if %s.Field == HUDStyle
8810                                 Style HUDStyleFlags
8811                         }))(obj)).WorldPos).serialize(w)
8812                 }); err != nil {
8813                         if err == io.EOF {
8814                                 chk(io.EOF)
8815                         }
8816                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
8817                 }
8818         }
8819         if (*(*(struct {
8820                 ID HUDID
8821
8822                 Field HUDField
8823
8824                 //mt:if %s.Field == HUDPos
8825                 Pos [2]float32
8826
8827                 //mt:if %s.Field == HUDName
8828                 Name string
8829
8830                 //mt:if %s.Field == HUDScale
8831                 Scale [2]float32
8832
8833                 //mt:if %s.Field == HUDText
8834                 Text string
8835
8836                 //mt:if %s.Field == HUDNumber
8837                 Number uint32
8838
8839                 //mt:if %s.Field == HUDItem
8840                 Item uint32
8841
8842                 //mt:if %s.Field == HUDDir
8843                 Dir uint32
8844
8845                 //mt:if %s.Field == HUDAlign
8846                 Align [2]float32
8847
8848                 //mt:if %s.Field == HUDOffset
8849                 Offset [2]float32
8850
8851                 //mt:if %s.Field == HUDWorldPos
8852                 WorldPos Pos
8853
8854                 //mt:if %s.Field == HUDSize
8855                 Size [2]int32
8856
8857                 //mt:if %s.Field == HUDZIndex
8858                 ZIndex int32
8859
8860                 //mt:if %s.Field == HUDText2
8861                 Text2 string
8862
8863                 //mt:if %s.Field == HUDStyle
8864                 Style HUDStyleFlags
8865         }))(obj)).Field == HUDSize {
8866                 for local176 := range (*(*(struct {
8867                         ID HUDID
8868
8869                         Field HUDField
8870
8871                         //mt:if %s.Field == HUDPos
8872                         Pos [2]float32
8873
8874                         //mt:if %s.Field == HUDName
8875                         Name string
8876
8877                         //mt:if %s.Field == HUDScale
8878                         Scale [2]float32
8879
8880                         //mt:if %s.Field == HUDText
8881                         Text string
8882
8883                         //mt:if %s.Field == HUDNumber
8884                         Number uint32
8885
8886                         //mt:if %s.Field == HUDItem
8887                         Item uint32
8888
8889                         //mt:if %s.Field == HUDDir
8890                         Dir uint32
8891
8892                         //mt:if %s.Field == HUDAlign
8893                         Align [2]float32
8894
8895                         //mt:if %s.Field == HUDOffset
8896                         Offset [2]float32
8897
8898                         //mt:if %s.Field == HUDWorldPos
8899                         WorldPos Pos
8900
8901                         //mt:if %s.Field == HUDSize
8902                         Size [2]int32
8903
8904                         //mt:if %s.Field == HUDZIndex
8905                         ZIndex int32
8906
8907                         //mt:if %s.Field == HUDText2
8908                         Text2 string
8909
8910                         //mt:if %s.Field == HUDStyle
8911                         Style HUDStyleFlags
8912                 }))(obj)).Size {
8913                         {
8914                                 x := ((*(*(struct {
8915                                         ID HUDID
8916
8917                                         Field HUDField
8918
8919                                         //mt:if %s.Field == HUDPos
8920                                         Pos [2]float32
8921
8922                                         //mt:if %s.Field == HUDName
8923                                         Name string
8924
8925                                         //mt:if %s.Field == HUDScale
8926                                         Scale [2]float32
8927
8928                                         //mt:if %s.Field == HUDText
8929                                         Text string
8930
8931                                         //mt:if %s.Field == HUDNumber
8932                                         Number uint32
8933
8934                                         //mt:if %s.Field == HUDItem
8935                                         Item uint32
8936
8937                                         //mt:if %s.Field == HUDDir
8938                                         Dir uint32
8939
8940                                         //mt:if %s.Field == HUDAlign
8941                                         Align [2]float32
8942
8943                                         //mt:if %s.Field == HUDOffset
8944                                         Offset [2]float32
8945
8946                                         //mt:if %s.Field == HUDWorldPos
8947                                         WorldPos Pos
8948
8949                                         //mt:if %s.Field == HUDSize
8950                                         Size [2]int32
8951
8952                                         //mt:if %s.Field == HUDZIndex
8953                                         ZIndex int32
8954
8955                                         //mt:if %s.Field == HUDText2
8956                                         Text2 string
8957
8958                                         //mt:if %s.Field == HUDStyle
8959                                         Style HUDStyleFlags
8960                                 }))(obj)).Size)[local176]
8961                                 write32(w, uint32(x))
8962                         }
8963                 }
8964         }
8965         if (*(*(struct {
8966                 ID HUDID
8967
8968                 Field HUDField
8969
8970                 //mt:if %s.Field == HUDPos
8971                 Pos [2]float32
8972
8973                 //mt:if %s.Field == HUDName
8974                 Name string
8975
8976                 //mt:if %s.Field == HUDScale
8977                 Scale [2]float32
8978
8979                 //mt:if %s.Field == HUDText
8980                 Text string
8981
8982                 //mt:if %s.Field == HUDNumber
8983                 Number uint32
8984
8985                 //mt:if %s.Field == HUDItem
8986                 Item uint32
8987
8988                 //mt:if %s.Field == HUDDir
8989                 Dir uint32
8990
8991                 //mt:if %s.Field == HUDAlign
8992                 Align [2]float32
8993
8994                 //mt:if %s.Field == HUDOffset
8995                 Offset [2]float32
8996
8997                 //mt:if %s.Field == HUDWorldPos
8998                 WorldPos Pos
8999
9000                 //mt:if %s.Field == HUDSize
9001                 Size [2]int32
9002
9003                 //mt:if %s.Field == HUDZIndex
9004                 ZIndex int32
9005
9006                 //mt:if %s.Field == HUDText2
9007                 Text2 string
9008
9009                 //mt:if %s.Field == HUDStyle
9010                 Style HUDStyleFlags
9011         }))(obj)).Field == HUDZIndex {
9012                 {
9013                         x := (*(*(struct {
9014                                 ID HUDID
9015
9016                                 Field HUDField
9017
9018                                 //mt:if %s.Field == HUDPos
9019                                 Pos [2]float32
9020
9021                                 //mt:if %s.Field == HUDName
9022                                 Name string
9023
9024                                 //mt:if %s.Field == HUDScale
9025                                 Scale [2]float32
9026
9027                                 //mt:if %s.Field == HUDText
9028                                 Text string
9029
9030                                 //mt:if %s.Field == HUDNumber
9031                                 Number uint32
9032
9033                                 //mt:if %s.Field == HUDItem
9034                                 Item uint32
9035
9036                                 //mt:if %s.Field == HUDDir
9037                                 Dir uint32
9038
9039                                 //mt:if %s.Field == HUDAlign
9040                                 Align [2]float32
9041
9042                                 //mt:if %s.Field == HUDOffset
9043                                 Offset [2]float32
9044
9045                                 //mt:if %s.Field == HUDWorldPos
9046                                 WorldPos Pos
9047
9048                                 //mt:if %s.Field == HUDSize
9049                                 Size [2]int32
9050
9051                                 //mt:if %s.Field == HUDZIndex
9052                                 ZIndex int32
9053
9054                                 //mt:if %s.Field == HUDText2
9055                                 Text2 string
9056
9057                                 //mt:if %s.Field == HUDStyle
9058                                 Style HUDStyleFlags
9059                         }))(obj)).ZIndex
9060                         write32(w, uint32(x))
9061                 }
9062         }
9063         if (*(*(struct {
9064                 ID HUDID
9065
9066                 Field HUDField
9067
9068                 //mt:if %s.Field == HUDPos
9069                 Pos [2]float32
9070
9071                 //mt:if %s.Field == HUDName
9072                 Name string
9073
9074                 //mt:if %s.Field == HUDScale
9075                 Scale [2]float32
9076
9077                 //mt:if %s.Field == HUDText
9078                 Text string
9079
9080                 //mt:if %s.Field == HUDNumber
9081                 Number uint32
9082
9083                 //mt:if %s.Field == HUDItem
9084                 Item uint32
9085
9086                 //mt:if %s.Field == HUDDir
9087                 Dir uint32
9088
9089                 //mt:if %s.Field == HUDAlign
9090                 Align [2]float32
9091
9092                 //mt:if %s.Field == HUDOffset
9093                 Offset [2]float32
9094
9095                 //mt:if %s.Field == HUDWorldPos
9096                 WorldPos Pos
9097
9098                 //mt:if %s.Field == HUDSize
9099                 Size [2]int32
9100
9101                 //mt:if %s.Field == HUDZIndex
9102                 ZIndex int32
9103
9104                 //mt:if %s.Field == HUDText2
9105                 Text2 string
9106
9107                 //mt:if %s.Field == HUDStyle
9108                 Style HUDStyleFlags
9109         }))(obj)).Field == HUDText2 {
9110                 if len(([]byte((*(*(struct {
9111                         ID HUDID
9112
9113                         Field HUDField
9114
9115                         //mt:if %s.Field == HUDPos
9116                         Pos [2]float32
9117
9118                         //mt:if %s.Field == HUDName
9119                         Name string
9120
9121                         //mt:if %s.Field == HUDScale
9122                         Scale [2]float32
9123
9124                         //mt:if %s.Field == HUDText
9125                         Text string
9126
9127                         //mt:if %s.Field == HUDNumber
9128                         Number uint32
9129
9130                         //mt:if %s.Field == HUDItem
9131                         Item uint32
9132
9133                         //mt:if %s.Field == HUDDir
9134                         Dir uint32
9135
9136                         //mt:if %s.Field == HUDAlign
9137                         Align [2]float32
9138
9139                         //mt:if %s.Field == HUDOffset
9140                         Offset [2]float32
9141
9142                         //mt:if %s.Field == HUDWorldPos
9143                         WorldPos Pos
9144
9145                         //mt:if %s.Field == HUDSize
9146                         Size [2]int32
9147
9148                         //mt:if %s.Field == HUDZIndex
9149                         ZIndex int32
9150
9151                         //mt:if %s.Field == HUDText2
9152                         Text2 string
9153
9154                         //mt:if %s.Field == HUDStyle
9155                         Style HUDStyleFlags
9156                 }))(obj)).Text2))) > math.MaxUint16 {
9157                         chk(ErrTooLong)
9158                 }
9159                 {
9160                         x := uint16(len(([]byte((*(*(struct {
9161                                 ID HUDID
9162
9163                                 Field HUDField
9164
9165                                 //mt:if %s.Field == HUDPos
9166                                 Pos [2]float32
9167
9168                                 //mt:if %s.Field == HUDName
9169                                 Name string
9170
9171                                 //mt:if %s.Field == HUDScale
9172                                 Scale [2]float32
9173
9174                                 //mt:if %s.Field == HUDText
9175                                 Text string
9176
9177                                 //mt:if %s.Field == HUDNumber
9178                                 Number uint32
9179
9180                                 //mt:if %s.Field == HUDItem
9181                                 Item uint32
9182
9183                                 //mt:if %s.Field == HUDDir
9184                                 Dir uint32
9185
9186                                 //mt:if %s.Field == HUDAlign
9187                                 Align [2]float32
9188
9189                                 //mt:if %s.Field == HUDOffset
9190                                 Offset [2]float32
9191
9192                                 //mt:if %s.Field == HUDWorldPos
9193                                 WorldPos Pos
9194
9195                                 //mt:if %s.Field == HUDSize
9196                                 Size [2]int32
9197
9198                                 //mt:if %s.Field == HUDZIndex
9199                                 ZIndex int32
9200
9201                                 //mt:if %s.Field == HUDText2
9202                                 Text2 string
9203
9204                                 //mt:if %s.Field == HUDStyle
9205                                 Style HUDStyleFlags
9206                         }))(obj)).Text2))))
9207                         write16(w, uint16(x))
9208                 }
9209                 {
9210                         _, err := w.Write(([]byte((*(*(struct {
9211                                 ID HUDID
9212
9213                                 Field HUDField
9214
9215                                 //mt:if %s.Field == HUDPos
9216                                 Pos [2]float32
9217
9218                                 //mt:if %s.Field == HUDName
9219                                 Name string
9220
9221                                 //mt:if %s.Field == HUDScale
9222                                 Scale [2]float32
9223
9224                                 //mt:if %s.Field == HUDText
9225                                 Text string
9226
9227                                 //mt:if %s.Field == HUDNumber
9228                                 Number uint32
9229
9230                                 //mt:if %s.Field == HUDItem
9231                                 Item uint32
9232
9233                                 //mt:if %s.Field == HUDDir
9234                                 Dir uint32
9235
9236                                 //mt:if %s.Field == HUDAlign
9237                                 Align [2]float32
9238
9239                                 //mt:if %s.Field == HUDOffset
9240                                 Offset [2]float32
9241
9242                                 //mt:if %s.Field == HUDWorldPos
9243                                 WorldPos Pos
9244
9245                                 //mt:if %s.Field == HUDSize
9246                                 Size [2]int32
9247
9248                                 //mt:if %s.Field == HUDZIndex
9249                                 ZIndex int32
9250
9251                                 //mt:if %s.Field == HUDText2
9252                                 Text2 string
9253
9254                                 //mt:if %s.Field == HUDStyle
9255                                 Style HUDStyleFlags
9256                         }))(obj)).Text2))[:])
9257                         chk(err)
9258                 }
9259         }
9260         if (*(*(struct {
9261                 ID HUDID
9262
9263                 Field HUDField
9264
9265                 //mt:if %s.Field == HUDPos
9266                 Pos [2]float32
9267
9268                 //mt:if %s.Field == HUDName
9269                 Name string
9270
9271                 //mt:if %s.Field == HUDScale
9272                 Scale [2]float32
9273
9274                 //mt:if %s.Field == HUDText
9275                 Text string
9276
9277                 //mt:if %s.Field == HUDNumber
9278                 Number uint32
9279
9280                 //mt:if %s.Field == HUDItem
9281                 Item uint32
9282
9283                 //mt:if %s.Field == HUDDir
9284                 Dir uint32
9285
9286                 //mt:if %s.Field == HUDAlign
9287                 Align [2]float32
9288
9289                 //mt:if %s.Field == HUDOffset
9290                 Offset [2]float32
9291
9292                 //mt:if %s.Field == HUDWorldPos
9293                 WorldPos Pos
9294
9295                 //mt:if %s.Field == HUDSize
9296                 Size [2]int32
9297
9298                 //mt:if %s.Field == HUDZIndex
9299                 ZIndex int32
9300
9301                 //mt:if %s.Field == HUDText2
9302                 Text2 string
9303
9304                 //mt:if %s.Field == HUDStyle
9305                 Style HUDStyleFlags
9306         }))(obj)).Field == HUDStyle {
9307                 if err := pcall(func() {
9308                         ((*(*(struct {
9309                                 ID HUDID
9310
9311                                 Field HUDField
9312
9313                                 //mt:if %s.Field == HUDPos
9314                                 Pos [2]float32
9315
9316                                 //mt:if %s.Field == HUDName
9317                                 Name string
9318
9319                                 //mt:if %s.Field == HUDScale
9320                                 Scale [2]float32
9321
9322                                 //mt:if %s.Field == HUDText
9323                                 Text string
9324
9325                                 //mt:if %s.Field == HUDNumber
9326                                 Number uint32
9327
9328                                 //mt:if %s.Field == HUDItem
9329                                 Item uint32
9330
9331                                 //mt:if %s.Field == HUDDir
9332                                 Dir uint32
9333
9334                                 //mt:if %s.Field == HUDAlign
9335                                 Align [2]float32
9336
9337                                 //mt:if %s.Field == HUDOffset
9338                                 Offset [2]float32
9339
9340                                 //mt:if %s.Field == HUDWorldPos
9341                                 WorldPos Pos
9342
9343                                 //mt:if %s.Field == HUDSize
9344                                 Size [2]int32
9345
9346                                 //mt:if %s.Field == HUDZIndex
9347                                 ZIndex int32
9348
9349                                 //mt:if %s.Field == HUDText2
9350                                 Text2 string
9351
9352                                 //mt:if %s.Field == HUDStyle
9353                                 Style HUDStyleFlags
9354                         }))(obj)).Style).serialize(w)
9355                 }); err != nil {
9356                         if err == io.EOF {
9357                                 chk(io.EOF)
9358                         }
9359                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
9360                 }
9361         }
9362 }
9363
9364 func (obj *ToCltChangeHUD) deserialize(r io.Reader) {
9365         if err := pcall(func() {
9366                 ((*(*(struct {
9367                         ID HUDID
9368
9369                         Field HUDField
9370
9371                         //mt:if %s.Field == HUDPos
9372                         Pos [2]float32
9373
9374                         //mt:if %s.Field == HUDName
9375                         Name string
9376
9377                         //mt:if %s.Field == HUDScale
9378                         Scale [2]float32
9379
9380                         //mt:if %s.Field == HUDText
9381                         Text string
9382
9383                         //mt:if %s.Field == HUDNumber
9384                         Number uint32
9385
9386                         //mt:if %s.Field == HUDItem
9387                         Item uint32
9388
9389                         //mt:if %s.Field == HUDDir
9390                         Dir uint32
9391
9392                         //mt:if %s.Field == HUDAlign
9393                         Align [2]float32
9394
9395                         //mt:if %s.Field == HUDOffset
9396                         Offset [2]float32
9397
9398                         //mt:if %s.Field == HUDWorldPos
9399                         WorldPos Pos
9400
9401                         //mt:if %s.Field == HUDSize
9402                         Size [2]int32
9403
9404                         //mt:if %s.Field == HUDZIndex
9405                         ZIndex int32
9406
9407                         //mt:if %s.Field == HUDText2
9408                         Text2 string
9409
9410                         //mt:if %s.Field == HUDStyle
9411                         Style HUDStyleFlags
9412                 }))(obj)).ID).deserialize(r)
9413         }); err != nil {
9414                 if err == io.EOF {
9415                         chk(io.EOF)
9416                 }
9417                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
9418         }
9419         if err := pcall(func() {
9420                 ((*(*(struct {
9421                         ID HUDID
9422
9423                         Field HUDField
9424
9425                         //mt:if %s.Field == HUDPos
9426                         Pos [2]float32
9427
9428                         //mt:if %s.Field == HUDName
9429                         Name string
9430
9431                         //mt:if %s.Field == HUDScale
9432                         Scale [2]float32
9433
9434                         //mt:if %s.Field == HUDText
9435                         Text string
9436
9437                         //mt:if %s.Field == HUDNumber
9438                         Number uint32
9439
9440                         //mt:if %s.Field == HUDItem
9441                         Item uint32
9442
9443                         //mt:if %s.Field == HUDDir
9444                         Dir uint32
9445
9446                         //mt:if %s.Field == HUDAlign
9447                         Align [2]float32
9448
9449                         //mt:if %s.Field == HUDOffset
9450                         Offset [2]float32
9451
9452                         //mt:if %s.Field == HUDWorldPos
9453                         WorldPos Pos
9454
9455                         //mt:if %s.Field == HUDSize
9456                         Size [2]int32
9457
9458                         //mt:if %s.Field == HUDZIndex
9459                         ZIndex int32
9460
9461                         //mt:if %s.Field == HUDText2
9462                         Text2 string
9463
9464                         //mt:if %s.Field == HUDStyle
9465                         Style HUDStyleFlags
9466                 }))(obj)).Field).deserialize(r)
9467         }); err != nil {
9468                 if err == io.EOF {
9469                         chk(io.EOF)
9470                 }
9471                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDField", err))
9472         }
9473         if !((*(*(struct {
9474                 ID HUDID
9475
9476                 Field HUDField
9477
9478                 //mt:if %s.Field == HUDPos
9479                 Pos [2]float32
9480
9481                 //mt:if %s.Field == HUDName
9482                 Name string
9483
9484                 //mt:if %s.Field == HUDScale
9485                 Scale [2]float32
9486
9487                 //mt:if %s.Field == HUDText
9488                 Text string
9489
9490                 //mt:if %s.Field == HUDNumber
9491                 Number uint32
9492
9493                 //mt:if %s.Field == HUDItem
9494                 Item uint32
9495
9496                 //mt:if %s.Field == HUDDir
9497                 Dir uint32
9498
9499                 //mt:if %s.Field == HUDAlign
9500                 Align [2]float32
9501
9502                 //mt:if %s.Field == HUDOffset
9503                 Offset [2]float32
9504
9505                 //mt:if %s.Field == HUDWorldPos
9506                 WorldPos Pos
9507
9508                 //mt:if %s.Field == HUDSize
9509                 Size [2]int32
9510
9511                 //mt:if %s.Field == HUDZIndex
9512                 ZIndex int32
9513
9514                 //mt:if %s.Field == HUDText2
9515                 Text2 string
9516
9517                 //mt:if %s.Field == HUDStyle
9518                 Style HUDStyleFlags
9519         }))(obj)).Field < hudMax) {
9520                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9521         }
9522         if (*(*(struct {
9523                 ID HUDID
9524
9525                 Field HUDField
9526
9527                 //mt:if %s.Field == HUDPos
9528                 Pos [2]float32
9529
9530                 //mt:if %s.Field == HUDName
9531                 Name string
9532
9533                 //mt:if %s.Field == HUDScale
9534                 Scale [2]float32
9535
9536                 //mt:if %s.Field == HUDText
9537                 Text string
9538
9539                 //mt:if %s.Field == HUDNumber
9540                 Number uint32
9541
9542                 //mt:if %s.Field == HUDItem
9543                 Item uint32
9544
9545                 //mt:if %s.Field == HUDDir
9546                 Dir uint32
9547
9548                 //mt:if %s.Field == HUDAlign
9549                 Align [2]float32
9550
9551                 //mt:if %s.Field == HUDOffset
9552                 Offset [2]float32
9553
9554                 //mt:if %s.Field == HUDWorldPos
9555                 WorldPos Pos
9556
9557                 //mt:if %s.Field == HUDSize
9558                 Size [2]int32
9559
9560                 //mt:if %s.Field == HUDZIndex
9561                 ZIndex int32
9562
9563                 //mt:if %s.Field == HUDText2
9564                 Text2 string
9565
9566                 //mt:if %s.Field == HUDStyle
9567                 Style HUDStyleFlags
9568         }))(obj)).Field == HUDPos {
9569                 for local177 := range (*(*(struct {
9570                         ID HUDID
9571
9572                         Field HUDField
9573
9574                         //mt:if %s.Field == HUDPos
9575                         Pos [2]float32
9576
9577                         //mt:if %s.Field == HUDName
9578                         Name string
9579
9580                         //mt:if %s.Field == HUDScale
9581                         Scale [2]float32
9582
9583                         //mt:if %s.Field == HUDText
9584                         Text string
9585
9586                         //mt:if %s.Field == HUDNumber
9587                         Number uint32
9588
9589                         //mt:if %s.Field == HUDItem
9590                         Item uint32
9591
9592                         //mt:if %s.Field == HUDDir
9593                         Dir uint32
9594
9595                         //mt:if %s.Field == HUDAlign
9596                         Align [2]float32
9597
9598                         //mt:if %s.Field == HUDOffset
9599                         Offset [2]float32
9600
9601                         //mt:if %s.Field == HUDWorldPos
9602                         WorldPos Pos
9603
9604                         //mt:if %s.Field == HUDSize
9605                         Size [2]int32
9606
9607                         //mt:if %s.Field == HUDZIndex
9608                         ZIndex int32
9609
9610                         //mt:if %s.Field == HUDText2
9611                         Text2 string
9612
9613                         //mt:if %s.Field == HUDStyle
9614                         Style HUDStyleFlags
9615                 }))(obj)).Pos {
9616                         {
9617                                 p := &((*(*(struct {
9618                                         ID HUDID
9619
9620                                         Field HUDField
9621
9622                                         //mt:if %s.Field == HUDPos
9623                                         Pos [2]float32
9624
9625                                         //mt:if %s.Field == HUDName
9626                                         Name string
9627
9628                                         //mt:if %s.Field == HUDScale
9629                                         Scale [2]float32
9630
9631                                         //mt:if %s.Field == HUDText
9632                                         Text string
9633
9634                                         //mt:if %s.Field == HUDNumber
9635                                         Number uint32
9636
9637                                         //mt:if %s.Field == HUDItem
9638                                         Item uint32
9639
9640                                         //mt:if %s.Field == HUDDir
9641                                         Dir uint32
9642
9643                                         //mt:if %s.Field == HUDAlign
9644                                         Align [2]float32
9645
9646                                         //mt:if %s.Field == HUDOffset
9647                                         Offset [2]float32
9648
9649                                         //mt:if %s.Field == HUDWorldPos
9650                                         WorldPos Pos
9651
9652                                         //mt:if %s.Field == HUDSize
9653                                         Size [2]int32
9654
9655                                         //mt:if %s.Field == HUDZIndex
9656                                         ZIndex int32
9657
9658                                         //mt:if %s.Field == HUDText2
9659                                         Text2 string
9660
9661                                         //mt:if %s.Field == HUDStyle
9662                                         Style HUDStyleFlags
9663                                 }))(obj)).Pos)[local177]
9664                                 *p = math.Float32frombits(read32(r))
9665                         }
9666                 }
9667         }
9668         if (*(*(struct {
9669                 ID HUDID
9670
9671                 Field HUDField
9672
9673                 //mt:if %s.Field == HUDPos
9674                 Pos [2]float32
9675
9676                 //mt:if %s.Field == HUDName
9677                 Name string
9678
9679                 //mt:if %s.Field == HUDScale
9680                 Scale [2]float32
9681
9682                 //mt:if %s.Field == HUDText
9683                 Text string
9684
9685                 //mt:if %s.Field == HUDNumber
9686                 Number uint32
9687
9688                 //mt:if %s.Field == HUDItem
9689                 Item uint32
9690
9691                 //mt:if %s.Field == HUDDir
9692                 Dir uint32
9693
9694                 //mt:if %s.Field == HUDAlign
9695                 Align [2]float32
9696
9697                 //mt:if %s.Field == HUDOffset
9698                 Offset [2]float32
9699
9700                 //mt:if %s.Field == HUDWorldPos
9701                 WorldPos Pos
9702
9703                 //mt:if %s.Field == HUDSize
9704                 Size [2]int32
9705
9706                 //mt:if %s.Field == HUDZIndex
9707                 ZIndex int32
9708
9709                 //mt:if %s.Field == HUDText2
9710                 Text2 string
9711
9712                 //mt:if %s.Field == HUDStyle
9713                 Style HUDStyleFlags
9714         }))(obj)).Field == HUDName {
9715                 var local178 []uint8
9716                 var local179 uint16
9717                 {
9718                         p := &local179
9719                         *p = read16(r)
9720                 }
9721                 (local178) = make([]uint8, local179)
9722                 {
9723                         _, err := io.ReadFull(r, (local178)[:])
9724                         chk(err)
9725                 }
9726                 ((*(*(struct {
9727                         ID HUDID
9728
9729                         Field HUDField
9730
9731                         //mt:if %s.Field == HUDPos
9732                         Pos [2]float32
9733
9734                         //mt:if %s.Field == HUDName
9735                         Name string
9736
9737                         //mt:if %s.Field == HUDScale
9738                         Scale [2]float32
9739
9740                         //mt:if %s.Field == HUDText
9741                         Text string
9742
9743                         //mt:if %s.Field == HUDNumber
9744                         Number uint32
9745
9746                         //mt:if %s.Field == HUDItem
9747                         Item uint32
9748
9749                         //mt:if %s.Field == HUDDir
9750                         Dir uint32
9751
9752                         //mt:if %s.Field == HUDAlign
9753                         Align [2]float32
9754
9755                         //mt:if %s.Field == HUDOffset
9756                         Offset [2]float32
9757
9758                         //mt:if %s.Field == HUDWorldPos
9759                         WorldPos Pos
9760
9761                         //mt:if %s.Field == HUDSize
9762                         Size [2]int32
9763
9764                         //mt:if %s.Field == HUDZIndex
9765                         ZIndex int32
9766
9767                         //mt:if %s.Field == HUDText2
9768                         Text2 string
9769
9770                         //mt:if %s.Field == HUDStyle
9771                         Style HUDStyleFlags
9772                 }))(obj)).Name) = string(local178)
9773         }
9774         if (*(*(struct {
9775                 ID HUDID
9776
9777                 Field HUDField
9778
9779                 //mt:if %s.Field == HUDPos
9780                 Pos [2]float32
9781
9782                 //mt:if %s.Field == HUDName
9783                 Name string
9784
9785                 //mt:if %s.Field == HUDScale
9786                 Scale [2]float32
9787
9788                 //mt:if %s.Field == HUDText
9789                 Text string
9790
9791                 //mt:if %s.Field == HUDNumber
9792                 Number uint32
9793
9794                 //mt:if %s.Field == HUDItem
9795                 Item uint32
9796
9797                 //mt:if %s.Field == HUDDir
9798                 Dir uint32
9799
9800                 //mt:if %s.Field == HUDAlign
9801                 Align [2]float32
9802
9803                 //mt:if %s.Field == HUDOffset
9804                 Offset [2]float32
9805
9806                 //mt:if %s.Field == HUDWorldPos
9807                 WorldPos Pos
9808
9809                 //mt:if %s.Field == HUDSize
9810                 Size [2]int32
9811
9812                 //mt:if %s.Field == HUDZIndex
9813                 ZIndex int32
9814
9815                 //mt:if %s.Field == HUDText2
9816                 Text2 string
9817
9818                 //mt:if %s.Field == HUDStyle
9819                 Style HUDStyleFlags
9820         }))(obj)).Field == HUDScale {
9821                 for local180 := range (*(*(struct {
9822                         ID HUDID
9823
9824                         Field HUDField
9825
9826                         //mt:if %s.Field == HUDPos
9827                         Pos [2]float32
9828
9829                         //mt:if %s.Field == HUDName
9830                         Name string
9831
9832                         //mt:if %s.Field == HUDScale
9833                         Scale [2]float32
9834
9835                         //mt:if %s.Field == HUDText
9836                         Text string
9837
9838                         //mt:if %s.Field == HUDNumber
9839                         Number uint32
9840
9841                         //mt:if %s.Field == HUDItem
9842                         Item uint32
9843
9844                         //mt:if %s.Field == HUDDir
9845                         Dir uint32
9846
9847                         //mt:if %s.Field == HUDAlign
9848                         Align [2]float32
9849
9850                         //mt:if %s.Field == HUDOffset
9851                         Offset [2]float32
9852
9853                         //mt:if %s.Field == HUDWorldPos
9854                         WorldPos Pos
9855
9856                         //mt:if %s.Field == HUDSize
9857                         Size [2]int32
9858
9859                         //mt:if %s.Field == HUDZIndex
9860                         ZIndex int32
9861
9862                         //mt:if %s.Field == HUDText2
9863                         Text2 string
9864
9865                         //mt:if %s.Field == HUDStyle
9866                         Style HUDStyleFlags
9867                 }))(obj)).Scale {
9868                         {
9869                                 p := &((*(*(struct {
9870                                         ID HUDID
9871
9872                                         Field HUDField
9873
9874                                         //mt:if %s.Field == HUDPos
9875                                         Pos [2]float32
9876
9877                                         //mt:if %s.Field == HUDName
9878                                         Name string
9879
9880                                         //mt:if %s.Field == HUDScale
9881                                         Scale [2]float32
9882
9883                                         //mt:if %s.Field == HUDText
9884                                         Text string
9885
9886                                         //mt:if %s.Field == HUDNumber
9887                                         Number uint32
9888
9889                                         //mt:if %s.Field == HUDItem
9890                                         Item uint32
9891
9892                                         //mt:if %s.Field == HUDDir
9893                                         Dir uint32
9894
9895                                         //mt:if %s.Field == HUDAlign
9896                                         Align [2]float32
9897
9898                                         //mt:if %s.Field == HUDOffset
9899                                         Offset [2]float32
9900
9901                                         //mt:if %s.Field == HUDWorldPos
9902                                         WorldPos Pos
9903
9904                                         //mt:if %s.Field == HUDSize
9905                                         Size [2]int32
9906
9907                                         //mt:if %s.Field == HUDZIndex
9908                                         ZIndex int32
9909
9910                                         //mt:if %s.Field == HUDText2
9911                                         Text2 string
9912
9913                                         //mt:if %s.Field == HUDStyle
9914                                         Style HUDStyleFlags
9915                                 }))(obj)).Scale)[local180]
9916                                 *p = math.Float32frombits(read32(r))
9917                         }
9918                 }
9919         }
9920         if (*(*(struct {
9921                 ID HUDID
9922
9923                 Field HUDField
9924
9925                 //mt:if %s.Field == HUDPos
9926                 Pos [2]float32
9927
9928                 //mt:if %s.Field == HUDName
9929                 Name string
9930
9931                 //mt:if %s.Field == HUDScale
9932                 Scale [2]float32
9933
9934                 //mt:if %s.Field == HUDText
9935                 Text string
9936
9937                 //mt:if %s.Field == HUDNumber
9938                 Number uint32
9939
9940                 //mt:if %s.Field == HUDItem
9941                 Item uint32
9942
9943                 //mt:if %s.Field == HUDDir
9944                 Dir uint32
9945
9946                 //mt:if %s.Field == HUDAlign
9947                 Align [2]float32
9948
9949                 //mt:if %s.Field == HUDOffset
9950                 Offset [2]float32
9951
9952                 //mt:if %s.Field == HUDWorldPos
9953                 WorldPos Pos
9954
9955                 //mt:if %s.Field == HUDSize
9956                 Size [2]int32
9957
9958                 //mt:if %s.Field == HUDZIndex
9959                 ZIndex int32
9960
9961                 //mt:if %s.Field == HUDText2
9962                 Text2 string
9963
9964                 //mt:if %s.Field == HUDStyle
9965                 Style HUDStyleFlags
9966         }))(obj)).Field == HUDText {
9967                 var local181 []uint8
9968                 var local182 uint16
9969                 {
9970                         p := &local182
9971                         *p = read16(r)
9972                 }
9973                 (local181) = make([]uint8, local182)
9974                 {
9975                         _, err := io.ReadFull(r, (local181)[:])
9976                         chk(err)
9977                 }
9978                 ((*(*(struct {
9979                         ID HUDID
9980
9981                         Field HUDField
9982
9983                         //mt:if %s.Field == HUDPos
9984                         Pos [2]float32
9985
9986                         //mt:if %s.Field == HUDName
9987                         Name string
9988
9989                         //mt:if %s.Field == HUDScale
9990                         Scale [2]float32
9991
9992                         //mt:if %s.Field == HUDText
9993                         Text string
9994
9995                         //mt:if %s.Field == HUDNumber
9996                         Number uint32
9997
9998                         //mt:if %s.Field == HUDItem
9999                         Item uint32
10000
10001                         //mt:if %s.Field == HUDDir
10002                         Dir uint32
10003
10004                         //mt:if %s.Field == HUDAlign
10005                         Align [2]float32
10006
10007                         //mt:if %s.Field == HUDOffset
10008                         Offset [2]float32
10009
10010                         //mt:if %s.Field == HUDWorldPos
10011                         WorldPos Pos
10012
10013                         //mt:if %s.Field == HUDSize
10014                         Size [2]int32
10015
10016                         //mt:if %s.Field == HUDZIndex
10017                         ZIndex int32
10018
10019                         //mt:if %s.Field == HUDText2
10020                         Text2 string
10021
10022                         //mt:if %s.Field == HUDStyle
10023                         Style HUDStyleFlags
10024                 }))(obj)).Text) = string(local181)
10025         }
10026         if (*(*(struct {
10027                 ID HUDID
10028
10029                 Field HUDField
10030
10031                 //mt:if %s.Field == HUDPos
10032                 Pos [2]float32
10033
10034                 //mt:if %s.Field == HUDName
10035                 Name string
10036
10037                 //mt:if %s.Field == HUDScale
10038                 Scale [2]float32
10039
10040                 //mt:if %s.Field == HUDText
10041                 Text string
10042
10043                 //mt:if %s.Field == HUDNumber
10044                 Number uint32
10045
10046                 //mt:if %s.Field == HUDItem
10047                 Item uint32
10048
10049                 //mt:if %s.Field == HUDDir
10050                 Dir uint32
10051
10052                 //mt:if %s.Field == HUDAlign
10053                 Align [2]float32
10054
10055                 //mt:if %s.Field == HUDOffset
10056                 Offset [2]float32
10057
10058                 //mt:if %s.Field == HUDWorldPos
10059                 WorldPos Pos
10060
10061                 //mt:if %s.Field == HUDSize
10062                 Size [2]int32
10063
10064                 //mt:if %s.Field == HUDZIndex
10065                 ZIndex int32
10066
10067                 //mt:if %s.Field == HUDText2
10068                 Text2 string
10069
10070                 //mt:if %s.Field == HUDStyle
10071                 Style HUDStyleFlags
10072         }))(obj)).Field == HUDNumber {
10073                 {
10074                         p := &(*(*(struct {
10075                                 ID HUDID
10076
10077                                 Field HUDField
10078
10079                                 //mt:if %s.Field == HUDPos
10080                                 Pos [2]float32
10081
10082                                 //mt:if %s.Field == HUDName
10083                                 Name string
10084
10085                                 //mt:if %s.Field == HUDScale
10086                                 Scale [2]float32
10087
10088                                 //mt:if %s.Field == HUDText
10089                                 Text string
10090
10091                                 //mt:if %s.Field == HUDNumber
10092                                 Number uint32
10093
10094                                 //mt:if %s.Field == HUDItem
10095                                 Item uint32
10096
10097                                 //mt:if %s.Field == HUDDir
10098                                 Dir uint32
10099
10100                                 //mt:if %s.Field == HUDAlign
10101                                 Align [2]float32
10102
10103                                 //mt:if %s.Field == HUDOffset
10104                                 Offset [2]float32
10105
10106                                 //mt:if %s.Field == HUDWorldPos
10107                                 WorldPos Pos
10108
10109                                 //mt:if %s.Field == HUDSize
10110                                 Size [2]int32
10111
10112                                 //mt:if %s.Field == HUDZIndex
10113                                 ZIndex int32
10114
10115                                 //mt:if %s.Field == HUDText2
10116                                 Text2 string
10117
10118                                 //mt:if %s.Field == HUDStyle
10119                                 Style HUDStyleFlags
10120                         }))(obj)).Number
10121                         *p = read32(r)
10122                 }
10123         }
10124         if (*(*(struct {
10125                 ID HUDID
10126
10127                 Field HUDField
10128
10129                 //mt:if %s.Field == HUDPos
10130                 Pos [2]float32
10131
10132                 //mt:if %s.Field == HUDName
10133                 Name string
10134
10135                 //mt:if %s.Field == HUDScale
10136                 Scale [2]float32
10137
10138                 //mt:if %s.Field == HUDText
10139                 Text string
10140
10141                 //mt:if %s.Field == HUDNumber
10142                 Number uint32
10143
10144                 //mt:if %s.Field == HUDItem
10145                 Item uint32
10146
10147                 //mt:if %s.Field == HUDDir
10148                 Dir uint32
10149
10150                 //mt:if %s.Field == HUDAlign
10151                 Align [2]float32
10152
10153                 //mt:if %s.Field == HUDOffset
10154                 Offset [2]float32
10155
10156                 //mt:if %s.Field == HUDWorldPos
10157                 WorldPos Pos
10158
10159                 //mt:if %s.Field == HUDSize
10160                 Size [2]int32
10161
10162                 //mt:if %s.Field == HUDZIndex
10163                 ZIndex int32
10164
10165                 //mt:if %s.Field == HUDText2
10166                 Text2 string
10167
10168                 //mt:if %s.Field == HUDStyle
10169                 Style HUDStyleFlags
10170         }))(obj)).Field == HUDItem {
10171                 {
10172                         p := &(*(*(struct {
10173                                 ID HUDID
10174
10175                                 Field HUDField
10176
10177                                 //mt:if %s.Field == HUDPos
10178                                 Pos [2]float32
10179
10180                                 //mt:if %s.Field == HUDName
10181                                 Name string
10182
10183                                 //mt:if %s.Field == HUDScale
10184                                 Scale [2]float32
10185
10186                                 //mt:if %s.Field == HUDText
10187                                 Text string
10188
10189                                 //mt:if %s.Field == HUDNumber
10190                                 Number uint32
10191
10192                                 //mt:if %s.Field == HUDItem
10193                                 Item uint32
10194
10195                                 //mt:if %s.Field == HUDDir
10196                                 Dir uint32
10197
10198                                 //mt:if %s.Field == HUDAlign
10199                                 Align [2]float32
10200
10201                                 //mt:if %s.Field == HUDOffset
10202                                 Offset [2]float32
10203
10204                                 //mt:if %s.Field == HUDWorldPos
10205                                 WorldPos Pos
10206
10207                                 //mt:if %s.Field == HUDSize
10208                                 Size [2]int32
10209
10210                                 //mt:if %s.Field == HUDZIndex
10211                                 ZIndex int32
10212
10213                                 //mt:if %s.Field == HUDText2
10214                                 Text2 string
10215
10216                                 //mt:if %s.Field == HUDStyle
10217                                 Style HUDStyleFlags
10218                         }))(obj)).Item
10219                         *p = read32(r)
10220                 }
10221         }
10222         if (*(*(struct {
10223                 ID HUDID
10224
10225                 Field HUDField
10226
10227                 //mt:if %s.Field == HUDPos
10228                 Pos [2]float32
10229
10230                 //mt:if %s.Field == HUDName
10231                 Name string
10232
10233                 //mt:if %s.Field == HUDScale
10234                 Scale [2]float32
10235
10236                 //mt:if %s.Field == HUDText
10237                 Text string
10238
10239                 //mt:if %s.Field == HUDNumber
10240                 Number uint32
10241
10242                 //mt:if %s.Field == HUDItem
10243                 Item uint32
10244
10245                 //mt:if %s.Field == HUDDir
10246                 Dir uint32
10247
10248                 //mt:if %s.Field == HUDAlign
10249                 Align [2]float32
10250
10251                 //mt:if %s.Field == HUDOffset
10252                 Offset [2]float32
10253
10254                 //mt:if %s.Field == HUDWorldPos
10255                 WorldPos Pos
10256
10257                 //mt:if %s.Field == HUDSize
10258                 Size [2]int32
10259
10260                 //mt:if %s.Field == HUDZIndex
10261                 ZIndex int32
10262
10263                 //mt:if %s.Field == HUDText2
10264                 Text2 string
10265
10266                 //mt:if %s.Field == HUDStyle
10267                 Style HUDStyleFlags
10268         }))(obj)).Field == HUDDir {
10269                 {
10270                         p := &(*(*(struct {
10271                                 ID HUDID
10272
10273                                 Field HUDField
10274
10275                                 //mt:if %s.Field == HUDPos
10276                                 Pos [2]float32
10277
10278                                 //mt:if %s.Field == HUDName
10279                                 Name string
10280
10281                                 //mt:if %s.Field == HUDScale
10282                                 Scale [2]float32
10283
10284                                 //mt:if %s.Field == HUDText
10285                                 Text string
10286
10287                                 //mt:if %s.Field == HUDNumber
10288                                 Number uint32
10289
10290                                 //mt:if %s.Field == HUDItem
10291                                 Item uint32
10292
10293                                 //mt:if %s.Field == HUDDir
10294                                 Dir uint32
10295
10296                                 //mt:if %s.Field == HUDAlign
10297                                 Align [2]float32
10298
10299                                 //mt:if %s.Field == HUDOffset
10300                                 Offset [2]float32
10301
10302                                 //mt:if %s.Field == HUDWorldPos
10303                                 WorldPos Pos
10304
10305                                 //mt:if %s.Field == HUDSize
10306                                 Size [2]int32
10307
10308                                 //mt:if %s.Field == HUDZIndex
10309                                 ZIndex int32
10310
10311                                 //mt:if %s.Field == HUDText2
10312                                 Text2 string
10313
10314                                 //mt:if %s.Field == HUDStyle
10315                                 Style HUDStyleFlags
10316                         }))(obj)).Dir
10317                         *p = read32(r)
10318                 }
10319         }
10320         if (*(*(struct {
10321                 ID HUDID
10322
10323                 Field HUDField
10324
10325                 //mt:if %s.Field == HUDPos
10326                 Pos [2]float32
10327
10328                 //mt:if %s.Field == HUDName
10329                 Name string
10330
10331                 //mt:if %s.Field == HUDScale
10332                 Scale [2]float32
10333
10334                 //mt:if %s.Field == HUDText
10335                 Text string
10336
10337                 //mt:if %s.Field == HUDNumber
10338                 Number uint32
10339
10340                 //mt:if %s.Field == HUDItem
10341                 Item uint32
10342
10343                 //mt:if %s.Field == HUDDir
10344                 Dir uint32
10345
10346                 //mt:if %s.Field == HUDAlign
10347                 Align [2]float32
10348
10349                 //mt:if %s.Field == HUDOffset
10350                 Offset [2]float32
10351
10352                 //mt:if %s.Field == HUDWorldPos
10353                 WorldPos Pos
10354
10355                 //mt:if %s.Field == HUDSize
10356                 Size [2]int32
10357
10358                 //mt:if %s.Field == HUDZIndex
10359                 ZIndex int32
10360
10361                 //mt:if %s.Field == HUDText2
10362                 Text2 string
10363
10364                 //mt:if %s.Field == HUDStyle
10365                 Style HUDStyleFlags
10366         }))(obj)).Field == HUDAlign {
10367                 for local183 := range (*(*(struct {
10368                         ID HUDID
10369
10370                         Field HUDField
10371
10372                         //mt:if %s.Field == HUDPos
10373                         Pos [2]float32
10374
10375                         //mt:if %s.Field == HUDName
10376                         Name string
10377
10378                         //mt:if %s.Field == HUDScale
10379                         Scale [2]float32
10380
10381                         //mt:if %s.Field == HUDText
10382                         Text string
10383
10384                         //mt:if %s.Field == HUDNumber
10385                         Number uint32
10386
10387                         //mt:if %s.Field == HUDItem
10388                         Item uint32
10389
10390                         //mt:if %s.Field == HUDDir
10391                         Dir uint32
10392
10393                         //mt:if %s.Field == HUDAlign
10394                         Align [2]float32
10395
10396                         //mt:if %s.Field == HUDOffset
10397                         Offset [2]float32
10398
10399                         //mt:if %s.Field == HUDWorldPos
10400                         WorldPos Pos
10401
10402                         //mt:if %s.Field == HUDSize
10403                         Size [2]int32
10404
10405                         //mt:if %s.Field == HUDZIndex
10406                         ZIndex int32
10407
10408                         //mt:if %s.Field == HUDText2
10409                         Text2 string
10410
10411                         //mt:if %s.Field == HUDStyle
10412                         Style HUDStyleFlags
10413                 }))(obj)).Align {
10414                         {
10415                                 p := &((*(*(struct {
10416                                         ID HUDID
10417
10418                                         Field HUDField
10419
10420                                         //mt:if %s.Field == HUDPos
10421                                         Pos [2]float32
10422
10423                                         //mt:if %s.Field == HUDName
10424                                         Name string
10425
10426                                         //mt:if %s.Field == HUDScale
10427                                         Scale [2]float32
10428
10429                                         //mt:if %s.Field == HUDText
10430                                         Text string
10431
10432                                         //mt:if %s.Field == HUDNumber
10433                                         Number uint32
10434
10435                                         //mt:if %s.Field == HUDItem
10436                                         Item uint32
10437
10438                                         //mt:if %s.Field == HUDDir
10439                                         Dir uint32
10440
10441                                         //mt:if %s.Field == HUDAlign
10442                                         Align [2]float32
10443
10444                                         //mt:if %s.Field == HUDOffset
10445                                         Offset [2]float32
10446
10447                                         //mt:if %s.Field == HUDWorldPos
10448                                         WorldPos Pos
10449
10450                                         //mt:if %s.Field == HUDSize
10451                                         Size [2]int32
10452
10453                                         //mt:if %s.Field == HUDZIndex
10454                                         ZIndex int32
10455
10456                                         //mt:if %s.Field == HUDText2
10457                                         Text2 string
10458
10459                                         //mt:if %s.Field == HUDStyle
10460                                         Style HUDStyleFlags
10461                                 }))(obj)).Align)[local183]
10462                                 *p = math.Float32frombits(read32(r))
10463                         }
10464                 }
10465         }
10466         if (*(*(struct {
10467                 ID HUDID
10468
10469                 Field HUDField
10470
10471                 //mt:if %s.Field == HUDPos
10472                 Pos [2]float32
10473
10474                 //mt:if %s.Field == HUDName
10475                 Name string
10476
10477                 //mt:if %s.Field == HUDScale
10478                 Scale [2]float32
10479
10480                 //mt:if %s.Field == HUDText
10481                 Text string
10482
10483                 //mt:if %s.Field == HUDNumber
10484                 Number uint32
10485
10486                 //mt:if %s.Field == HUDItem
10487                 Item uint32
10488
10489                 //mt:if %s.Field == HUDDir
10490                 Dir uint32
10491
10492                 //mt:if %s.Field == HUDAlign
10493                 Align [2]float32
10494
10495                 //mt:if %s.Field == HUDOffset
10496                 Offset [2]float32
10497
10498                 //mt:if %s.Field == HUDWorldPos
10499                 WorldPos Pos
10500
10501                 //mt:if %s.Field == HUDSize
10502                 Size [2]int32
10503
10504                 //mt:if %s.Field == HUDZIndex
10505                 ZIndex int32
10506
10507                 //mt:if %s.Field == HUDText2
10508                 Text2 string
10509
10510                 //mt:if %s.Field == HUDStyle
10511                 Style HUDStyleFlags
10512         }))(obj)).Field == HUDOffset {
10513                 for local184 := range (*(*(struct {
10514                         ID HUDID
10515
10516                         Field HUDField
10517
10518                         //mt:if %s.Field == HUDPos
10519                         Pos [2]float32
10520
10521                         //mt:if %s.Field == HUDName
10522                         Name string
10523
10524                         //mt:if %s.Field == HUDScale
10525                         Scale [2]float32
10526
10527                         //mt:if %s.Field == HUDText
10528                         Text string
10529
10530                         //mt:if %s.Field == HUDNumber
10531                         Number uint32
10532
10533                         //mt:if %s.Field == HUDItem
10534                         Item uint32
10535
10536                         //mt:if %s.Field == HUDDir
10537                         Dir uint32
10538
10539                         //mt:if %s.Field == HUDAlign
10540                         Align [2]float32
10541
10542                         //mt:if %s.Field == HUDOffset
10543                         Offset [2]float32
10544
10545                         //mt:if %s.Field == HUDWorldPos
10546                         WorldPos Pos
10547
10548                         //mt:if %s.Field == HUDSize
10549                         Size [2]int32
10550
10551                         //mt:if %s.Field == HUDZIndex
10552                         ZIndex int32
10553
10554                         //mt:if %s.Field == HUDText2
10555                         Text2 string
10556
10557                         //mt:if %s.Field == HUDStyle
10558                         Style HUDStyleFlags
10559                 }))(obj)).Offset {
10560                         {
10561                                 p := &((*(*(struct {
10562                                         ID HUDID
10563
10564                                         Field HUDField
10565
10566                                         //mt:if %s.Field == HUDPos
10567                                         Pos [2]float32
10568
10569                                         //mt:if %s.Field == HUDName
10570                                         Name string
10571
10572                                         //mt:if %s.Field == HUDScale
10573                                         Scale [2]float32
10574
10575                                         //mt:if %s.Field == HUDText
10576                                         Text string
10577
10578                                         //mt:if %s.Field == HUDNumber
10579                                         Number uint32
10580
10581                                         //mt:if %s.Field == HUDItem
10582                                         Item uint32
10583
10584                                         //mt:if %s.Field == HUDDir
10585                                         Dir uint32
10586
10587                                         //mt:if %s.Field == HUDAlign
10588                                         Align [2]float32
10589
10590                                         //mt:if %s.Field == HUDOffset
10591                                         Offset [2]float32
10592
10593                                         //mt:if %s.Field == HUDWorldPos
10594                                         WorldPos Pos
10595
10596                                         //mt:if %s.Field == HUDSize
10597                                         Size [2]int32
10598
10599                                         //mt:if %s.Field == HUDZIndex
10600                                         ZIndex int32
10601
10602                                         //mt:if %s.Field == HUDText2
10603                                         Text2 string
10604
10605                                         //mt:if %s.Field == HUDStyle
10606                                         Style HUDStyleFlags
10607                                 }))(obj)).Offset)[local184]
10608                                 *p = math.Float32frombits(read32(r))
10609                         }
10610                 }
10611         }
10612         if (*(*(struct {
10613                 ID HUDID
10614
10615                 Field HUDField
10616
10617                 //mt:if %s.Field == HUDPos
10618                 Pos [2]float32
10619
10620                 //mt:if %s.Field == HUDName
10621                 Name string
10622
10623                 //mt:if %s.Field == HUDScale
10624                 Scale [2]float32
10625
10626                 //mt:if %s.Field == HUDText
10627                 Text string
10628
10629                 //mt:if %s.Field == HUDNumber
10630                 Number uint32
10631
10632                 //mt:if %s.Field == HUDItem
10633                 Item uint32
10634
10635                 //mt:if %s.Field == HUDDir
10636                 Dir uint32
10637
10638                 //mt:if %s.Field == HUDAlign
10639                 Align [2]float32
10640
10641                 //mt:if %s.Field == HUDOffset
10642                 Offset [2]float32
10643
10644                 //mt:if %s.Field == HUDWorldPos
10645                 WorldPos Pos
10646
10647                 //mt:if %s.Field == HUDSize
10648                 Size [2]int32
10649
10650                 //mt:if %s.Field == HUDZIndex
10651                 ZIndex int32
10652
10653                 //mt:if %s.Field == HUDText2
10654                 Text2 string
10655
10656                 //mt:if %s.Field == HUDStyle
10657                 Style HUDStyleFlags
10658         }))(obj)).Field == HUDWorldPos {
10659                 if err := pcall(func() {
10660                         ((*(*(struct {
10661                                 ID HUDID
10662
10663                                 Field HUDField
10664
10665                                 //mt:if %s.Field == HUDPos
10666                                 Pos [2]float32
10667
10668                                 //mt:if %s.Field == HUDName
10669                                 Name string
10670
10671                                 //mt:if %s.Field == HUDScale
10672                                 Scale [2]float32
10673
10674                                 //mt:if %s.Field == HUDText
10675                                 Text string
10676
10677                                 //mt:if %s.Field == HUDNumber
10678                                 Number uint32
10679
10680                                 //mt:if %s.Field == HUDItem
10681                                 Item uint32
10682
10683                                 //mt:if %s.Field == HUDDir
10684                                 Dir uint32
10685
10686                                 //mt:if %s.Field == HUDAlign
10687                                 Align [2]float32
10688
10689                                 //mt:if %s.Field == HUDOffset
10690                                 Offset [2]float32
10691
10692                                 //mt:if %s.Field == HUDWorldPos
10693                                 WorldPos Pos
10694
10695                                 //mt:if %s.Field == HUDSize
10696                                 Size [2]int32
10697
10698                                 //mt:if %s.Field == HUDZIndex
10699                                 ZIndex int32
10700
10701                                 //mt:if %s.Field == HUDText2
10702                                 Text2 string
10703
10704                                 //mt:if %s.Field == HUDStyle
10705                                 Style HUDStyleFlags
10706                         }))(obj)).WorldPos).deserialize(r)
10707                 }); err != nil {
10708                         if err == io.EOF {
10709                                 chk(io.EOF)
10710                         }
10711                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
10712                 }
10713         }
10714         if (*(*(struct {
10715                 ID HUDID
10716
10717                 Field HUDField
10718
10719                 //mt:if %s.Field == HUDPos
10720                 Pos [2]float32
10721
10722                 //mt:if %s.Field == HUDName
10723                 Name string
10724
10725                 //mt:if %s.Field == HUDScale
10726                 Scale [2]float32
10727
10728                 //mt:if %s.Field == HUDText
10729                 Text string
10730
10731                 //mt:if %s.Field == HUDNumber
10732                 Number uint32
10733
10734                 //mt:if %s.Field == HUDItem
10735                 Item uint32
10736
10737                 //mt:if %s.Field == HUDDir
10738                 Dir uint32
10739
10740                 //mt:if %s.Field == HUDAlign
10741                 Align [2]float32
10742
10743                 //mt:if %s.Field == HUDOffset
10744                 Offset [2]float32
10745
10746                 //mt:if %s.Field == HUDWorldPos
10747                 WorldPos Pos
10748
10749                 //mt:if %s.Field == HUDSize
10750                 Size [2]int32
10751
10752                 //mt:if %s.Field == HUDZIndex
10753                 ZIndex int32
10754
10755                 //mt:if %s.Field == HUDText2
10756                 Text2 string
10757
10758                 //mt:if %s.Field == HUDStyle
10759                 Style HUDStyleFlags
10760         }))(obj)).Field == HUDSize {
10761                 for local185 := range (*(*(struct {
10762                         ID HUDID
10763
10764                         Field HUDField
10765
10766                         //mt:if %s.Field == HUDPos
10767                         Pos [2]float32
10768
10769                         //mt:if %s.Field == HUDName
10770                         Name string
10771
10772                         //mt:if %s.Field == HUDScale
10773                         Scale [2]float32
10774
10775                         //mt:if %s.Field == HUDText
10776                         Text string
10777
10778                         //mt:if %s.Field == HUDNumber
10779                         Number uint32
10780
10781                         //mt:if %s.Field == HUDItem
10782                         Item uint32
10783
10784                         //mt:if %s.Field == HUDDir
10785                         Dir uint32
10786
10787                         //mt:if %s.Field == HUDAlign
10788                         Align [2]float32
10789
10790                         //mt:if %s.Field == HUDOffset
10791                         Offset [2]float32
10792
10793                         //mt:if %s.Field == HUDWorldPos
10794                         WorldPos Pos
10795
10796                         //mt:if %s.Field == HUDSize
10797                         Size [2]int32
10798
10799                         //mt:if %s.Field == HUDZIndex
10800                         ZIndex int32
10801
10802                         //mt:if %s.Field == HUDText2
10803                         Text2 string
10804
10805                         //mt:if %s.Field == HUDStyle
10806                         Style HUDStyleFlags
10807                 }))(obj)).Size {
10808                         {
10809                                 p := &((*(*(struct {
10810                                         ID HUDID
10811
10812                                         Field HUDField
10813
10814                                         //mt:if %s.Field == HUDPos
10815                                         Pos [2]float32
10816
10817                                         //mt:if %s.Field == HUDName
10818                                         Name string
10819
10820                                         //mt:if %s.Field == HUDScale
10821                                         Scale [2]float32
10822
10823                                         //mt:if %s.Field == HUDText
10824                                         Text string
10825
10826                                         //mt:if %s.Field == HUDNumber
10827                                         Number uint32
10828
10829                                         //mt:if %s.Field == HUDItem
10830                                         Item uint32
10831
10832                                         //mt:if %s.Field == HUDDir
10833                                         Dir uint32
10834
10835                                         //mt:if %s.Field == HUDAlign
10836                                         Align [2]float32
10837
10838                                         //mt:if %s.Field == HUDOffset
10839                                         Offset [2]float32
10840
10841                                         //mt:if %s.Field == HUDWorldPos
10842                                         WorldPos Pos
10843
10844                                         //mt:if %s.Field == HUDSize
10845                                         Size [2]int32
10846
10847                                         //mt:if %s.Field == HUDZIndex
10848                                         ZIndex int32
10849
10850                                         //mt:if %s.Field == HUDText2
10851                                         Text2 string
10852
10853                                         //mt:if %s.Field == HUDStyle
10854                                         Style HUDStyleFlags
10855                                 }))(obj)).Size)[local185]
10856                                 *p = int32(read32(r))
10857                         }
10858                 }
10859         }
10860         if (*(*(struct {
10861                 ID HUDID
10862
10863                 Field HUDField
10864
10865                 //mt:if %s.Field == HUDPos
10866                 Pos [2]float32
10867
10868                 //mt:if %s.Field == HUDName
10869                 Name string
10870
10871                 //mt:if %s.Field == HUDScale
10872                 Scale [2]float32
10873
10874                 //mt:if %s.Field == HUDText
10875                 Text string
10876
10877                 //mt:if %s.Field == HUDNumber
10878                 Number uint32
10879
10880                 //mt:if %s.Field == HUDItem
10881                 Item uint32
10882
10883                 //mt:if %s.Field == HUDDir
10884                 Dir uint32
10885
10886                 //mt:if %s.Field == HUDAlign
10887                 Align [2]float32
10888
10889                 //mt:if %s.Field == HUDOffset
10890                 Offset [2]float32
10891
10892                 //mt:if %s.Field == HUDWorldPos
10893                 WorldPos Pos
10894
10895                 //mt:if %s.Field == HUDSize
10896                 Size [2]int32
10897
10898                 //mt:if %s.Field == HUDZIndex
10899                 ZIndex int32
10900
10901                 //mt:if %s.Field == HUDText2
10902                 Text2 string
10903
10904                 //mt:if %s.Field == HUDStyle
10905                 Style HUDStyleFlags
10906         }))(obj)).Field == HUDZIndex {
10907                 {
10908                         p := &(*(*(struct {
10909                                 ID HUDID
10910
10911                                 Field HUDField
10912
10913                                 //mt:if %s.Field == HUDPos
10914                                 Pos [2]float32
10915
10916                                 //mt:if %s.Field == HUDName
10917                                 Name string
10918
10919                                 //mt:if %s.Field == HUDScale
10920                                 Scale [2]float32
10921
10922                                 //mt:if %s.Field == HUDText
10923                                 Text string
10924
10925                                 //mt:if %s.Field == HUDNumber
10926                                 Number uint32
10927
10928                                 //mt:if %s.Field == HUDItem
10929                                 Item uint32
10930
10931                                 //mt:if %s.Field == HUDDir
10932                                 Dir uint32
10933
10934                                 //mt:if %s.Field == HUDAlign
10935                                 Align [2]float32
10936
10937                                 //mt:if %s.Field == HUDOffset
10938                                 Offset [2]float32
10939
10940                                 //mt:if %s.Field == HUDWorldPos
10941                                 WorldPos Pos
10942
10943                                 //mt:if %s.Field == HUDSize
10944                                 Size [2]int32
10945
10946                                 //mt:if %s.Field == HUDZIndex
10947                                 ZIndex int32
10948
10949                                 //mt:if %s.Field == HUDText2
10950                                 Text2 string
10951
10952                                 //mt:if %s.Field == HUDStyle
10953                                 Style HUDStyleFlags
10954                         }))(obj)).ZIndex
10955                         *p = int32(read32(r))
10956                 }
10957         }
10958         if (*(*(struct {
10959                 ID HUDID
10960
10961                 Field HUDField
10962
10963                 //mt:if %s.Field == HUDPos
10964                 Pos [2]float32
10965
10966                 //mt:if %s.Field == HUDName
10967                 Name string
10968
10969                 //mt:if %s.Field == HUDScale
10970                 Scale [2]float32
10971
10972                 //mt:if %s.Field == HUDText
10973                 Text string
10974
10975                 //mt:if %s.Field == HUDNumber
10976                 Number uint32
10977
10978                 //mt:if %s.Field == HUDItem
10979                 Item uint32
10980
10981                 //mt:if %s.Field == HUDDir
10982                 Dir uint32
10983
10984                 //mt:if %s.Field == HUDAlign
10985                 Align [2]float32
10986
10987                 //mt:if %s.Field == HUDOffset
10988                 Offset [2]float32
10989
10990                 //mt:if %s.Field == HUDWorldPos
10991                 WorldPos Pos
10992
10993                 //mt:if %s.Field == HUDSize
10994                 Size [2]int32
10995
10996                 //mt:if %s.Field == HUDZIndex
10997                 ZIndex int32
10998
10999                 //mt:if %s.Field == HUDText2
11000                 Text2 string
11001
11002                 //mt:if %s.Field == HUDStyle
11003                 Style HUDStyleFlags
11004         }))(obj)).Field == HUDText2 {
11005                 var local186 []uint8
11006                 var local187 uint16
11007                 {
11008                         p := &local187
11009                         *p = read16(r)
11010                 }
11011                 (local186) = make([]uint8, local187)
11012                 {
11013                         _, err := io.ReadFull(r, (local186)[:])
11014                         chk(err)
11015                 }
11016                 ((*(*(struct {
11017                         ID HUDID
11018
11019                         Field HUDField
11020
11021                         //mt:if %s.Field == HUDPos
11022                         Pos [2]float32
11023
11024                         //mt:if %s.Field == HUDName
11025                         Name string
11026
11027                         //mt:if %s.Field == HUDScale
11028                         Scale [2]float32
11029
11030                         //mt:if %s.Field == HUDText
11031                         Text string
11032
11033                         //mt:if %s.Field == HUDNumber
11034                         Number uint32
11035
11036                         //mt:if %s.Field == HUDItem
11037                         Item uint32
11038
11039                         //mt:if %s.Field == HUDDir
11040                         Dir uint32
11041
11042                         //mt:if %s.Field == HUDAlign
11043                         Align [2]float32
11044
11045                         //mt:if %s.Field == HUDOffset
11046                         Offset [2]float32
11047
11048                         //mt:if %s.Field == HUDWorldPos
11049                         WorldPos Pos
11050
11051                         //mt:if %s.Field == HUDSize
11052                         Size [2]int32
11053
11054                         //mt:if %s.Field == HUDZIndex
11055                         ZIndex int32
11056
11057                         //mt:if %s.Field == HUDText2
11058                         Text2 string
11059
11060                         //mt:if %s.Field == HUDStyle
11061                         Style HUDStyleFlags
11062                 }))(obj)).Text2) = string(local186)
11063         }
11064         if (*(*(struct {
11065                 ID HUDID
11066
11067                 Field HUDField
11068
11069                 //mt:if %s.Field == HUDPos
11070                 Pos [2]float32
11071
11072                 //mt:if %s.Field == HUDName
11073                 Name string
11074
11075                 //mt:if %s.Field == HUDScale
11076                 Scale [2]float32
11077
11078                 //mt:if %s.Field == HUDText
11079                 Text string
11080
11081                 //mt:if %s.Field == HUDNumber
11082                 Number uint32
11083
11084                 //mt:if %s.Field == HUDItem
11085                 Item uint32
11086
11087                 //mt:if %s.Field == HUDDir
11088                 Dir uint32
11089
11090                 //mt:if %s.Field == HUDAlign
11091                 Align [2]float32
11092
11093                 //mt:if %s.Field == HUDOffset
11094                 Offset [2]float32
11095
11096                 //mt:if %s.Field == HUDWorldPos
11097                 WorldPos Pos
11098
11099                 //mt:if %s.Field == HUDSize
11100                 Size [2]int32
11101
11102                 //mt:if %s.Field == HUDZIndex
11103                 ZIndex int32
11104
11105                 //mt:if %s.Field == HUDText2
11106                 Text2 string
11107
11108                 //mt:if %s.Field == HUDStyle
11109                 Style HUDStyleFlags
11110         }))(obj)).Field == HUDStyle {
11111                 if err := pcall(func() {
11112                         ((*(*(struct {
11113                                 ID HUDID
11114
11115                                 Field HUDField
11116
11117                                 //mt:if %s.Field == HUDPos
11118                                 Pos [2]float32
11119
11120                                 //mt:if %s.Field == HUDName
11121                                 Name string
11122
11123                                 //mt:if %s.Field == HUDScale
11124                                 Scale [2]float32
11125
11126                                 //mt:if %s.Field == HUDText
11127                                 Text string
11128
11129                                 //mt:if %s.Field == HUDNumber
11130                                 Number uint32
11131
11132                                 //mt:if %s.Field == HUDItem
11133                                 Item uint32
11134
11135                                 //mt:if %s.Field == HUDDir
11136                                 Dir uint32
11137
11138                                 //mt:if %s.Field == HUDAlign
11139                                 Align [2]float32
11140
11141                                 //mt:if %s.Field == HUDOffset
11142                                 Offset [2]float32
11143
11144                                 //mt:if %s.Field == HUDWorldPos
11145                                 WorldPos Pos
11146
11147                                 //mt:if %s.Field == HUDSize
11148                                 Size [2]int32
11149
11150                                 //mt:if %s.Field == HUDZIndex
11151                                 ZIndex int32
11152
11153                                 //mt:if %s.Field == HUDText2
11154                                 Text2 string
11155
11156                                 //mt:if %s.Field == HUDStyle
11157                                 Style HUDStyleFlags
11158                         }))(obj)).Style).deserialize(r)
11159                 }); err != nil {
11160                         if err == io.EOF {
11161                                 chk(io.EOF)
11162                         }
11163                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
11164                 }
11165         }
11166 }
11167
11168 func (obj *ToCltHUDFlags) serialize(w io.Writer) {
11169         if err := pcall(func() {
11170                 ((*(*(struct {
11171                         // &^= Mask
11172                         // |= Flags
11173                         Flags, Mask HUDFlags
11174                 }))(obj)).Flags).serialize(w)
11175         }); err != nil {
11176                 if err == io.EOF {
11177                         chk(io.EOF)
11178                 }
11179                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11180         }
11181         if err := pcall(func() {
11182                 ((*(*(struct {
11183                         // &^= Mask
11184                         // |= Flags
11185                         Flags, Mask HUDFlags
11186                 }))(obj)).Mask).serialize(w)
11187         }); err != nil {
11188                 if err == io.EOF {
11189                         chk(io.EOF)
11190                 }
11191                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11192         }
11193 }
11194
11195 func (obj *ToCltHUDFlags) deserialize(r io.Reader) {
11196         if err := pcall(func() {
11197                 ((*(*(struct {
11198                         // &^= Mask
11199                         // |= Flags
11200                         Flags, Mask HUDFlags
11201                 }))(obj)).Flags).deserialize(r)
11202         }); err != nil {
11203                 if err == io.EOF {
11204                         chk(io.EOF)
11205                 }
11206                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11207         }
11208         if err := pcall(func() {
11209                 ((*(*(struct {
11210                         // &^= Mask
11211                         // |= Flags
11212                         Flags, Mask HUDFlags
11213                 }))(obj)).Mask).deserialize(r)
11214         }); err != nil {
11215                 if err == io.EOF {
11216                         chk(io.EOF)
11217                 }
11218                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11219         }
11220 }
11221
11222 func (obj *ToCltSetHotbarParam) serialize(w io.Writer) {
11223         if err := pcall(func() {
11224                 ((*(*(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).serialize(w)
11234         }); err != nil {
11235                 if err == io.EOF {
11236                         chk(io.EOF)
11237                 }
11238                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HotbarParam", err))
11239         }
11240         if (*(*(struct {
11241                 Param HotbarParam
11242
11243                 //mt:if %s.Param == HotbarSize
11244                 //mt:const uint16(4) // Size of Size field.
11245                 Size int32
11246
11247                 //mt:if %s.Param != HotbarSize
11248                 Img Texture
11249         }))(obj)).Param == HotbarSize {
11250                 {
11251                         local188 := uint16(4) // Size of Size field.
11252                         {
11253                                 x := local188
11254                                 write16(w, uint16(x))
11255                         }
11256                 }
11257                 {
11258                         x := (*(*(struct {
11259                                 Param HotbarParam
11260
11261                                 //mt:if %s.Param == HotbarSize
11262                                 //mt:const uint16(4) // Size of Size field.
11263                                 Size int32
11264
11265                                 //mt:if %s.Param != HotbarSize
11266                                 Img Texture
11267                         }))(obj)).Size
11268                         write32(w, uint32(x))
11269                 }
11270         }
11271         if (*(*(struct {
11272                 Param HotbarParam
11273
11274                 //mt:if %s.Param == HotbarSize
11275                 //mt:const uint16(4) // Size of Size field.
11276                 Size int32
11277
11278                 //mt:if %s.Param != HotbarSize
11279                 Img Texture
11280         }))(obj)).Param != HotbarSize {
11281                 if err := pcall(func() {
11282                         ((*(*(struct {
11283                                 Param HotbarParam
11284
11285                                 //mt:if %s.Param == HotbarSize
11286                                 //mt:const uint16(4) // Size of Size field.
11287                                 Size int32
11288
11289                                 //mt:if %s.Param != HotbarSize
11290                                 Img Texture
11291                         }))(obj)).Img).serialize(w)
11292                 }); err != nil {
11293                         if err == io.EOF {
11294                                 chk(io.EOF)
11295                         }
11296                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11297                 }
11298         }
11299 }
11300
11301 func (obj *ToCltSetHotbarParam) deserialize(r io.Reader) {
11302         if err := pcall(func() {
11303                 ((*(*(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).deserialize(r)
11313         }); err != nil {
11314                 if err == io.EOF {
11315                         chk(io.EOF)
11316                 }
11317                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HotbarParam", err))
11318         }
11319         if (*(*(struct {
11320                 Param HotbarParam
11321
11322                 //mt:if %s.Param == HotbarSize
11323                 //mt:const uint16(4) // Size of Size field.
11324                 Size int32
11325
11326                 //mt:if %s.Param != HotbarSize
11327                 Img Texture
11328         }))(obj)).Param == HotbarSize {
11329                 {
11330                         var local189 uint16
11331                         local190 := uint16(4) // Size of Size field.
11332                         {
11333                                 p := &local189
11334                                 *p = read16(r)
11335                         }
11336                         if local189 != local190 {
11337                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local189))
11338                         }
11339                 }
11340                 {
11341                         p := &(*(*(struct {
11342                                 Param HotbarParam
11343
11344                                 //mt:if %s.Param == HotbarSize
11345                                 //mt:const uint16(4) // Size of Size field.
11346                                 Size int32
11347
11348                                 //mt:if %s.Param != HotbarSize
11349                                 Img Texture
11350                         }))(obj)).Size
11351                         *p = int32(read32(r))
11352                 }
11353         }
11354         if (*(*(struct {
11355                 Param HotbarParam
11356
11357                 //mt:if %s.Param == HotbarSize
11358                 //mt:const uint16(4) // Size of Size field.
11359                 Size int32
11360
11361                 //mt:if %s.Param != HotbarSize
11362                 Img Texture
11363         }))(obj)).Param != HotbarSize {
11364                 if err := pcall(func() {
11365                         ((*(*(struct {
11366                                 Param HotbarParam
11367
11368                                 //mt:if %s.Param == HotbarSize
11369                                 //mt:const uint16(4) // Size of Size field.
11370                                 Size int32
11371
11372                                 //mt:if %s.Param != HotbarSize
11373                                 Img Texture
11374                         }))(obj)).Img).deserialize(r)
11375                 }); err != nil {
11376                         if err == io.EOF {
11377                                 chk(io.EOF)
11378                         }
11379                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11380                 }
11381         }
11382 }
11383
11384 func (obj *ToCltBreath) serialize(w io.Writer) {
11385         {
11386                 x := (*(*(struct {
11387                         Breath uint16
11388                 }))(obj)).Breath
11389                 write16(w, uint16(x))
11390         }
11391 }
11392
11393 func (obj *ToCltBreath) deserialize(r io.Reader) {
11394         {
11395                 p := &(*(*(struct {
11396                         Breath uint16
11397                 }))(obj)).Breath
11398                 *p = read16(r)
11399         }
11400 }
11401
11402 func (obj *ToCltSkyParams) serialize(w io.Writer) {
11403         {
11404                 x := (*(*(struct {
11405                         BgColor     color.NRGBA
11406                         Type        string
11407                         Clouds      bool
11408                         SunFogTint  color.NRGBA
11409                         MoonFogTint color.NRGBA
11410                         FogTintType string
11411
11412                         //mt:if %s.Type == "skybox"
11413                         Textures []Texture
11414
11415                         //mt:if %s.Type == "regular"
11416                         DaySky, DayHorizon,
11417                         DawnSky, DawnHorizon,
11418                         NightSky, NightHorizon,
11419                         Indoor color.NRGBA
11420                 }))(obj)).BgColor
11421                 w.Write([]byte{x.A, x.R, x.G, x.B})
11422         }
11423         if len(([]byte((*(*(struct {
11424                 BgColor     color.NRGBA
11425                 Type        string
11426                 Clouds      bool
11427                 SunFogTint  color.NRGBA
11428                 MoonFogTint color.NRGBA
11429                 FogTintType string
11430
11431                 //mt:if %s.Type == "skybox"
11432                 Textures []Texture
11433
11434                 //mt:if %s.Type == "regular"
11435                 DaySky, DayHorizon,
11436                 DawnSky, DawnHorizon,
11437                 NightSky, NightHorizon,
11438                 Indoor color.NRGBA
11439         }))(obj)).Type))) > math.MaxUint16 {
11440                 chk(ErrTooLong)
11441         }
11442         {
11443                 x := uint16(len(([]byte((*(*(struct {
11444                         BgColor     color.NRGBA
11445                         Type        string
11446                         Clouds      bool
11447                         SunFogTint  color.NRGBA
11448                         MoonFogTint color.NRGBA
11449                         FogTintType string
11450
11451                         //mt:if %s.Type == "skybox"
11452                         Textures []Texture
11453
11454                         //mt:if %s.Type == "regular"
11455                         DaySky, DayHorizon,
11456                         DawnSky, DawnHorizon,
11457                         NightSky, NightHorizon,
11458                         Indoor color.NRGBA
11459                 }))(obj)).Type))))
11460                 write16(w, uint16(x))
11461         }
11462         {
11463                 _, err := w.Write(([]byte((*(*(struct {
11464                         BgColor     color.NRGBA
11465                         Type        string
11466                         Clouds      bool
11467                         SunFogTint  color.NRGBA
11468                         MoonFogTint color.NRGBA
11469                         FogTintType string
11470
11471                         //mt:if %s.Type == "skybox"
11472                         Textures []Texture
11473
11474                         //mt:if %s.Type == "regular"
11475                         DaySky, DayHorizon,
11476                         DawnSky, DawnHorizon,
11477                         NightSky, NightHorizon,
11478                         Indoor color.NRGBA
11479                 }))(obj)).Type))[:])
11480                 chk(err)
11481         }
11482         {
11483                 x := (*(*(struct {
11484                         BgColor     color.NRGBA
11485                         Type        string
11486                         Clouds      bool
11487                         SunFogTint  color.NRGBA
11488                         MoonFogTint color.NRGBA
11489                         FogTintType string
11490
11491                         //mt:if %s.Type == "skybox"
11492                         Textures []Texture
11493
11494                         //mt:if %s.Type == "regular"
11495                         DaySky, DayHorizon,
11496                         DawnSky, DawnHorizon,
11497                         NightSky, NightHorizon,
11498                         Indoor color.NRGBA
11499                 }))(obj)).Clouds
11500                 if x {
11501                         write8(w, 1)
11502                 } else {
11503                         write8(w, 0)
11504                 }
11505         }
11506         {
11507                 x := (*(*(struct {
11508                         BgColor     color.NRGBA
11509                         Type        string
11510                         Clouds      bool
11511                         SunFogTint  color.NRGBA
11512                         MoonFogTint color.NRGBA
11513                         FogTintType string
11514
11515                         //mt:if %s.Type == "skybox"
11516                         Textures []Texture
11517
11518                         //mt:if %s.Type == "regular"
11519                         DaySky, DayHorizon,
11520                         DawnSky, DawnHorizon,
11521                         NightSky, NightHorizon,
11522                         Indoor color.NRGBA
11523                 }))(obj)).SunFogTint
11524                 w.Write([]byte{x.A, x.R, x.G, x.B})
11525         }
11526         {
11527                 x := (*(*(struct {
11528                         BgColor     color.NRGBA
11529                         Type        string
11530                         Clouds      bool
11531                         SunFogTint  color.NRGBA
11532                         MoonFogTint color.NRGBA
11533                         FogTintType string
11534
11535                         //mt:if %s.Type == "skybox"
11536                         Textures []Texture
11537
11538                         //mt:if %s.Type == "regular"
11539                         DaySky, DayHorizon,
11540                         DawnSky, DawnHorizon,
11541                         NightSky, NightHorizon,
11542                         Indoor color.NRGBA
11543                 }))(obj)).MoonFogTint
11544                 w.Write([]byte{x.A, x.R, x.G, x.B})
11545         }
11546         if len(([]byte((*(*(struct {
11547                 BgColor     color.NRGBA
11548                 Type        string
11549                 Clouds      bool
11550                 SunFogTint  color.NRGBA
11551                 MoonFogTint color.NRGBA
11552                 FogTintType string
11553
11554                 //mt:if %s.Type == "skybox"
11555                 Textures []Texture
11556
11557                 //mt:if %s.Type == "regular"
11558                 DaySky, DayHorizon,
11559                 DawnSky, DawnHorizon,
11560                 NightSky, NightHorizon,
11561                 Indoor color.NRGBA
11562         }))(obj)).FogTintType))) > math.MaxUint16 {
11563                 chk(ErrTooLong)
11564         }
11565         {
11566                 x := uint16(len(([]byte((*(*(struct {
11567                         BgColor     color.NRGBA
11568                         Type        string
11569                         Clouds      bool
11570                         SunFogTint  color.NRGBA
11571                         MoonFogTint color.NRGBA
11572                         FogTintType string
11573
11574                         //mt:if %s.Type == "skybox"
11575                         Textures []Texture
11576
11577                         //mt:if %s.Type == "regular"
11578                         DaySky, DayHorizon,
11579                         DawnSky, DawnHorizon,
11580                         NightSky, NightHorizon,
11581                         Indoor color.NRGBA
11582                 }))(obj)).FogTintType))))
11583                 write16(w, uint16(x))
11584         }
11585         {
11586                 _, err := w.Write(([]byte((*(*(struct {
11587                         BgColor     color.NRGBA
11588                         Type        string
11589                         Clouds      bool
11590                         SunFogTint  color.NRGBA
11591                         MoonFogTint color.NRGBA
11592                         FogTintType string
11593
11594                         //mt:if %s.Type == "skybox"
11595                         Textures []Texture
11596
11597                         //mt:if %s.Type == "regular"
11598                         DaySky, DayHorizon,
11599                         DawnSky, DawnHorizon,
11600                         NightSky, NightHorizon,
11601                         Indoor color.NRGBA
11602                 }))(obj)).FogTintType))[:])
11603                 chk(err)
11604         }
11605         if (*(*(struct {
11606                 BgColor     color.NRGBA
11607                 Type        string
11608                 Clouds      bool
11609                 SunFogTint  color.NRGBA
11610                 MoonFogTint color.NRGBA
11611                 FogTintType string
11612
11613                 //mt:if %s.Type == "skybox"
11614                 Textures []Texture
11615
11616                 //mt:if %s.Type == "regular"
11617                 DaySky, DayHorizon,
11618                 DawnSky, DawnHorizon,
11619                 NightSky, NightHorizon,
11620                 Indoor color.NRGBA
11621         }))(obj)).Type == "skybox" {
11622                 if len(((*(*(struct {
11623                         BgColor     color.NRGBA
11624                         Type        string
11625                         Clouds      bool
11626                         SunFogTint  color.NRGBA
11627                         MoonFogTint color.NRGBA
11628                         FogTintType string
11629
11630                         //mt:if %s.Type == "skybox"
11631                         Textures []Texture
11632
11633                         //mt:if %s.Type == "regular"
11634                         DaySky, DayHorizon,
11635                         DawnSky, DawnHorizon,
11636                         NightSky, NightHorizon,
11637                         Indoor color.NRGBA
11638                 }))(obj)).Textures)) > math.MaxUint16 {
11639                         chk(ErrTooLong)
11640                 }
11641                 {
11642                         x := uint16(len(((*(*(struct {
11643                                 BgColor     color.NRGBA
11644                                 Type        string
11645                                 Clouds      bool
11646                                 SunFogTint  color.NRGBA
11647                                 MoonFogTint color.NRGBA
11648                                 FogTintType string
11649
11650                                 //mt:if %s.Type == "skybox"
11651                                 Textures []Texture
11652
11653                                 //mt:if %s.Type == "regular"
11654                                 DaySky, DayHorizon,
11655                                 DawnSky, DawnHorizon,
11656                                 NightSky, NightHorizon,
11657                                 Indoor color.NRGBA
11658                         }))(obj)).Textures)))
11659                         write16(w, uint16(x))
11660                 }
11661                 for local191 := range (*(*(struct {
11662                         BgColor     color.NRGBA
11663                         Type        string
11664                         Clouds      bool
11665                         SunFogTint  color.NRGBA
11666                         MoonFogTint color.NRGBA
11667                         FogTintType string
11668
11669                         //mt:if %s.Type == "skybox"
11670                         Textures []Texture
11671
11672                         //mt:if %s.Type == "regular"
11673                         DaySky, DayHorizon,
11674                         DawnSky, DawnHorizon,
11675                         NightSky, NightHorizon,
11676                         Indoor color.NRGBA
11677                 }))(obj)).Textures {
11678                         if err := pcall(func() {
11679                                 (((*(*(struct {
11680                                         BgColor     color.NRGBA
11681                                         Type        string
11682                                         Clouds      bool
11683                                         SunFogTint  color.NRGBA
11684                                         MoonFogTint color.NRGBA
11685                                         FogTintType string
11686
11687                                         //mt:if %s.Type == "skybox"
11688                                         Textures []Texture
11689
11690                                         //mt:if %s.Type == "regular"
11691                                         DaySky, DayHorizon,
11692                                         DawnSky, DawnHorizon,
11693                                         NightSky, NightHorizon,
11694                                         Indoor color.NRGBA
11695                                 }))(obj)).Textures)[local191]).serialize(w)
11696                         }); err != nil {
11697                                 if err == io.EOF {
11698                                         chk(io.EOF)
11699                                 }
11700                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11701                         }
11702                 }
11703         }
11704         if (*(*(struct {
11705                 BgColor     color.NRGBA
11706                 Type        string
11707                 Clouds      bool
11708                 SunFogTint  color.NRGBA
11709                 MoonFogTint color.NRGBA
11710                 FogTintType string
11711
11712                 //mt:if %s.Type == "skybox"
11713                 Textures []Texture
11714
11715                 //mt:if %s.Type == "regular"
11716                 DaySky, DayHorizon,
11717                 DawnSky, DawnHorizon,
11718                 NightSky, NightHorizon,
11719                 Indoor color.NRGBA
11720         }))(obj)).Type == "regular" {
11721                 {
11722                         x := (*(*(struct {
11723                                 BgColor     color.NRGBA
11724                                 Type        string
11725                                 Clouds      bool
11726                                 SunFogTint  color.NRGBA
11727                                 MoonFogTint color.NRGBA
11728                                 FogTintType string
11729
11730                                 //mt:if %s.Type == "skybox"
11731                                 Textures []Texture
11732
11733                                 //mt:if %s.Type == "regular"
11734                                 DaySky, DayHorizon,
11735                                 DawnSky, DawnHorizon,
11736                                 NightSky, NightHorizon,
11737                                 Indoor color.NRGBA
11738                         }))(obj)).DaySky
11739                         w.Write([]byte{x.A, x.R, x.G, x.B})
11740                 }
11741                 {
11742                         x := (*(*(struct {
11743                                 BgColor     color.NRGBA
11744                                 Type        string
11745                                 Clouds      bool
11746                                 SunFogTint  color.NRGBA
11747                                 MoonFogTint color.NRGBA
11748                                 FogTintType string
11749
11750                                 //mt:if %s.Type == "skybox"
11751                                 Textures []Texture
11752
11753                                 //mt:if %s.Type == "regular"
11754                                 DaySky, DayHorizon,
11755                                 DawnSky, DawnHorizon,
11756                                 NightSky, NightHorizon,
11757                                 Indoor color.NRGBA
11758                         }))(obj)).DayHorizon
11759                         w.Write([]byte{x.A, x.R, x.G, x.B})
11760                 }
11761                 {
11762                         x := (*(*(struct {
11763                                 BgColor     color.NRGBA
11764                                 Type        string
11765                                 Clouds      bool
11766                                 SunFogTint  color.NRGBA
11767                                 MoonFogTint color.NRGBA
11768                                 FogTintType string
11769
11770                                 //mt:if %s.Type == "skybox"
11771                                 Textures []Texture
11772
11773                                 //mt:if %s.Type == "regular"
11774                                 DaySky, DayHorizon,
11775                                 DawnSky, DawnHorizon,
11776                                 NightSky, NightHorizon,
11777                                 Indoor color.NRGBA
11778                         }))(obj)).DawnSky
11779                         w.Write([]byte{x.A, x.R, x.G, x.B})
11780                 }
11781                 {
11782                         x := (*(*(struct {
11783                                 BgColor     color.NRGBA
11784                                 Type        string
11785                                 Clouds      bool
11786                                 SunFogTint  color.NRGBA
11787                                 MoonFogTint color.NRGBA
11788                                 FogTintType string
11789
11790                                 //mt:if %s.Type == "skybox"
11791                                 Textures []Texture
11792
11793                                 //mt:if %s.Type == "regular"
11794                                 DaySky, DayHorizon,
11795                                 DawnSky, DawnHorizon,
11796                                 NightSky, NightHorizon,
11797                                 Indoor color.NRGBA
11798                         }))(obj)).DawnHorizon
11799                         w.Write([]byte{x.A, x.R, x.G, x.B})
11800                 }
11801                 {
11802                         x := (*(*(struct {
11803                                 BgColor     color.NRGBA
11804                                 Type        string
11805                                 Clouds      bool
11806                                 SunFogTint  color.NRGBA
11807                                 MoonFogTint color.NRGBA
11808                                 FogTintType string
11809
11810                                 //mt:if %s.Type == "skybox"
11811                                 Textures []Texture
11812
11813                                 //mt:if %s.Type == "regular"
11814                                 DaySky, DayHorizon,
11815                                 DawnSky, DawnHorizon,
11816                                 NightSky, NightHorizon,
11817                                 Indoor color.NRGBA
11818                         }))(obj)).NightSky
11819                         w.Write([]byte{x.A, x.R, x.G, x.B})
11820                 }
11821                 {
11822                         x := (*(*(struct {
11823                                 BgColor     color.NRGBA
11824                                 Type        string
11825                                 Clouds      bool
11826                                 SunFogTint  color.NRGBA
11827                                 MoonFogTint color.NRGBA
11828                                 FogTintType string
11829
11830                                 //mt:if %s.Type == "skybox"
11831                                 Textures []Texture
11832
11833                                 //mt:if %s.Type == "regular"
11834                                 DaySky, DayHorizon,
11835                                 DawnSky, DawnHorizon,
11836                                 NightSky, NightHorizon,
11837                                 Indoor color.NRGBA
11838                         }))(obj)).NightHorizon
11839                         w.Write([]byte{x.A, x.R, x.G, x.B})
11840                 }
11841                 {
11842                         x := (*(*(struct {
11843                                 BgColor     color.NRGBA
11844                                 Type        string
11845                                 Clouds      bool
11846                                 SunFogTint  color.NRGBA
11847                                 MoonFogTint color.NRGBA
11848                                 FogTintType string
11849
11850                                 //mt:if %s.Type == "skybox"
11851                                 Textures []Texture
11852
11853                                 //mt:if %s.Type == "regular"
11854                                 DaySky, DayHorizon,
11855                                 DawnSky, DawnHorizon,
11856                                 NightSky, NightHorizon,
11857                                 Indoor color.NRGBA
11858                         }))(obj)).Indoor
11859                         w.Write([]byte{x.A, x.R, x.G, x.B})
11860                 }
11861         }
11862 }
11863
11864 func (obj *ToCltSkyParams) deserialize(r io.Reader) {
11865         {
11866                 p := &(*(*(struct {
11867                         BgColor     color.NRGBA
11868                         Type        string
11869                         Clouds      bool
11870                         SunFogTint  color.NRGBA
11871                         MoonFogTint color.NRGBA
11872                         FogTintType string
11873
11874                         //mt:if %s.Type == "skybox"
11875                         Textures []Texture
11876
11877                         //mt:if %s.Type == "regular"
11878                         DaySky, DayHorizon,
11879                         DawnSky, DawnHorizon,
11880                         NightSky, NightHorizon,
11881                         Indoor color.NRGBA
11882                 }))(obj)).BgColor
11883                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11884         }
11885         var local192 []uint8
11886         var local193 uint16
11887         {
11888                 p := &local193
11889                 *p = read16(r)
11890         }
11891         (local192) = make([]uint8, local193)
11892         {
11893                 _, err := io.ReadFull(r, (local192)[:])
11894                 chk(err)
11895         }
11896         ((*(*(struct {
11897                 BgColor     color.NRGBA
11898                 Type        string
11899                 Clouds      bool
11900                 SunFogTint  color.NRGBA
11901                 MoonFogTint color.NRGBA
11902                 FogTintType string
11903
11904                 //mt:if %s.Type == "skybox"
11905                 Textures []Texture
11906
11907                 //mt:if %s.Type == "regular"
11908                 DaySky, DayHorizon,
11909                 DawnSky, DawnHorizon,
11910                 NightSky, NightHorizon,
11911                 Indoor color.NRGBA
11912         }))(obj)).Type) = string(local192)
11913         {
11914                 p := &(*(*(struct {
11915                         BgColor     color.NRGBA
11916                         Type        string
11917                         Clouds      bool
11918                         SunFogTint  color.NRGBA
11919                         MoonFogTint color.NRGBA
11920                         FogTintType string
11921
11922                         //mt:if %s.Type == "skybox"
11923                         Textures []Texture
11924
11925                         //mt:if %s.Type == "regular"
11926                         DaySky, DayHorizon,
11927                         DawnSky, DawnHorizon,
11928                         NightSky, NightHorizon,
11929                         Indoor color.NRGBA
11930                 }))(obj)).Clouds
11931                 switch n := read8(r); n {
11932                 case 0:
11933                         *p = false
11934                 case 1:
11935                         *p = true
11936                 default:
11937                         chk(fmt.Errorf("invalid bool: %d", n))
11938                 }
11939         }
11940         {
11941                 p := &(*(*(struct {
11942                         BgColor     color.NRGBA
11943                         Type        string
11944                         Clouds      bool
11945                         SunFogTint  color.NRGBA
11946                         MoonFogTint color.NRGBA
11947                         FogTintType string
11948
11949                         //mt:if %s.Type == "skybox"
11950                         Textures []Texture
11951
11952                         //mt:if %s.Type == "regular"
11953                         DaySky, DayHorizon,
11954                         DawnSky, DawnHorizon,
11955                         NightSky, NightHorizon,
11956                         Indoor color.NRGBA
11957                 }))(obj)).SunFogTint
11958                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11959         }
11960         {
11961                 p := &(*(*(struct {
11962                         BgColor     color.NRGBA
11963                         Type        string
11964                         Clouds      bool
11965                         SunFogTint  color.NRGBA
11966                         MoonFogTint color.NRGBA
11967                         FogTintType string
11968
11969                         //mt:if %s.Type == "skybox"
11970                         Textures []Texture
11971
11972                         //mt:if %s.Type == "regular"
11973                         DaySky, DayHorizon,
11974                         DawnSky, DawnHorizon,
11975                         NightSky, NightHorizon,
11976                         Indoor color.NRGBA
11977                 }))(obj)).MoonFogTint
11978                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11979         }
11980         var local194 []uint8
11981         var local195 uint16
11982         {
11983                 p := &local195
11984                 *p = read16(r)
11985         }
11986         (local194) = make([]uint8, local195)
11987         {
11988                 _, err := io.ReadFull(r, (local194)[:])
11989                 chk(err)
11990         }
11991         ((*(*(struct {
11992                 BgColor     color.NRGBA
11993                 Type        string
11994                 Clouds      bool
11995                 SunFogTint  color.NRGBA
11996                 MoonFogTint color.NRGBA
11997                 FogTintType string
11998
11999                 //mt:if %s.Type == "skybox"
12000                 Textures []Texture
12001
12002                 //mt:if %s.Type == "regular"
12003                 DaySky, DayHorizon,
12004                 DawnSky, DawnHorizon,
12005                 NightSky, NightHorizon,
12006                 Indoor color.NRGBA
12007         }))(obj)).FogTintType) = string(local194)
12008         if (*(*(struct {
12009                 BgColor     color.NRGBA
12010                 Type        string
12011                 Clouds      bool
12012                 SunFogTint  color.NRGBA
12013                 MoonFogTint color.NRGBA
12014                 FogTintType string
12015
12016                 //mt:if %s.Type == "skybox"
12017                 Textures []Texture
12018
12019                 //mt:if %s.Type == "regular"
12020                 DaySky, DayHorizon,
12021                 DawnSky, DawnHorizon,
12022                 NightSky, NightHorizon,
12023                 Indoor color.NRGBA
12024         }))(obj)).Type == "skybox" {
12025                 var local196 uint16
12026                 {
12027                         p := &local196
12028                         *p = read16(r)
12029                 }
12030                 ((*(*(struct {
12031                         BgColor     color.NRGBA
12032                         Type        string
12033                         Clouds      bool
12034                         SunFogTint  color.NRGBA
12035                         MoonFogTint color.NRGBA
12036                         FogTintType string
12037
12038                         //mt:if %s.Type == "skybox"
12039                         Textures []Texture
12040
12041                         //mt:if %s.Type == "regular"
12042                         DaySky, DayHorizon,
12043                         DawnSky, DawnHorizon,
12044                         NightSky, NightHorizon,
12045                         Indoor color.NRGBA
12046                 }))(obj)).Textures) = make([]Texture, local196)
12047                 for local197 := range (*(*(struct {
12048                         BgColor     color.NRGBA
12049                         Type        string
12050                         Clouds      bool
12051                         SunFogTint  color.NRGBA
12052                         MoonFogTint color.NRGBA
12053                         FogTintType string
12054
12055                         //mt:if %s.Type == "skybox"
12056                         Textures []Texture
12057
12058                         //mt:if %s.Type == "regular"
12059                         DaySky, DayHorizon,
12060                         DawnSky, DawnHorizon,
12061                         NightSky, NightHorizon,
12062                         Indoor color.NRGBA
12063                 }))(obj)).Textures {
12064                         if err := pcall(func() {
12065                                 (((*(*(struct {
12066                                         BgColor     color.NRGBA
12067                                         Type        string
12068                                         Clouds      bool
12069                                         SunFogTint  color.NRGBA
12070                                         MoonFogTint color.NRGBA
12071                                         FogTintType string
12072
12073                                         //mt:if %s.Type == "skybox"
12074                                         Textures []Texture
12075
12076                                         //mt:if %s.Type == "regular"
12077                                         DaySky, DayHorizon,
12078                                         DawnSky, DawnHorizon,
12079                                         NightSky, NightHorizon,
12080                                         Indoor color.NRGBA
12081                                 }))(obj)).Textures)[local197]).deserialize(r)
12082                         }); err != nil {
12083                                 if err == io.EOF {
12084                                         chk(io.EOF)
12085                                 }
12086                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
12087                         }
12088                 }
12089         }
12090         if (*(*(struct {
12091                 BgColor     color.NRGBA
12092                 Type        string
12093                 Clouds      bool
12094                 SunFogTint  color.NRGBA
12095                 MoonFogTint color.NRGBA
12096                 FogTintType string
12097
12098                 //mt:if %s.Type == "skybox"
12099                 Textures []Texture
12100
12101                 //mt:if %s.Type == "regular"
12102                 DaySky, DayHorizon,
12103                 DawnSky, DawnHorizon,
12104                 NightSky, NightHorizon,
12105                 Indoor color.NRGBA
12106         }))(obj)).Type == "regular" {
12107                 {
12108                         p := &(*(*(struct {
12109                                 BgColor     color.NRGBA
12110                                 Type        string
12111                                 Clouds      bool
12112                                 SunFogTint  color.NRGBA
12113                                 MoonFogTint color.NRGBA
12114                                 FogTintType string
12115
12116                                 //mt:if %s.Type == "skybox"
12117                                 Textures []Texture
12118
12119                                 //mt:if %s.Type == "regular"
12120                                 DaySky, DayHorizon,
12121                                 DawnSky, DawnHorizon,
12122                                 NightSky, NightHorizon,
12123                                 Indoor color.NRGBA
12124                         }))(obj)).DaySky
12125                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12126                 }
12127                 {
12128                         p := &(*(*(struct {
12129                                 BgColor     color.NRGBA
12130                                 Type        string
12131                                 Clouds      bool
12132                                 SunFogTint  color.NRGBA
12133                                 MoonFogTint color.NRGBA
12134                                 FogTintType string
12135
12136                                 //mt:if %s.Type == "skybox"
12137                                 Textures []Texture
12138
12139                                 //mt:if %s.Type == "regular"
12140                                 DaySky, DayHorizon,
12141                                 DawnSky, DawnHorizon,
12142                                 NightSky, NightHorizon,
12143                                 Indoor color.NRGBA
12144                         }))(obj)).DayHorizon
12145                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12146                 }
12147                 {
12148                         p := &(*(*(struct {
12149                                 BgColor     color.NRGBA
12150                                 Type        string
12151                                 Clouds      bool
12152                                 SunFogTint  color.NRGBA
12153                                 MoonFogTint color.NRGBA
12154                                 FogTintType string
12155
12156                                 //mt:if %s.Type == "skybox"
12157                                 Textures []Texture
12158
12159                                 //mt:if %s.Type == "regular"
12160                                 DaySky, DayHorizon,
12161                                 DawnSky, DawnHorizon,
12162                                 NightSky, NightHorizon,
12163                                 Indoor color.NRGBA
12164                         }))(obj)).DawnSky
12165                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12166                 }
12167                 {
12168                         p := &(*(*(struct {
12169                                 BgColor     color.NRGBA
12170                                 Type        string
12171                                 Clouds      bool
12172                                 SunFogTint  color.NRGBA
12173                                 MoonFogTint color.NRGBA
12174                                 FogTintType string
12175
12176                                 //mt:if %s.Type == "skybox"
12177                                 Textures []Texture
12178
12179                                 //mt:if %s.Type == "regular"
12180                                 DaySky, DayHorizon,
12181                                 DawnSky, DawnHorizon,
12182                                 NightSky, NightHorizon,
12183                                 Indoor color.NRGBA
12184                         }))(obj)).DawnHorizon
12185                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12186                 }
12187                 {
12188                         p := &(*(*(struct {
12189                                 BgColor     color.NRGBA
12190                                 Type        string
12191                                 Clouds      bool
12192                                 SunFogTint  color.NRGBA
12193                                 MoonFogTint color.NRGBA
12194                                 FogTintType string
12195
12196                                 //mt:if %s.Type == "skybox"
12197                                 Textures []Texture
12198
12199                                 //mt:if %s.Type == "regular"
12200                                 DaySky, DayHorizon,
12201                                 DawnSky, DawnHorizon,
12202                                 NightSky, NightHorizon,
12203                                 Indoor color.NRGBA
12204                         }))(obj)).NightSky
12205                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12206                 }
12207                 {
12208                         p := &(*(*(struct {
12209                                 BgColor     color.NRGBA
12210                                 Type        string
12211                                 Clouds      bool
12212                                 SunFogTint  color.NRGBA
12213                                 MoonFogTint color.NRGBA
12214                                 FogTintType string
12215
12216                                 //mt:if %s.Type == "skybox"
12217                                 Textures []Texture
12218
12219                                 //mt:if %s.Type == "regular"
12220                                 DaySky, DayHorizon,
12221                                 DawnSky, DawnHorizon,
12222                                 NightSky, NightHorizon,
12223                                 Indoor color.NRGBA
12224                         }))(obj)).NightHorizon
12225                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12226                 }
12227                 {
12228                         p := &(*(*(struct {
12229                                 BgColor     color.NRGBA
12230                                 Type        string
12231                                 Clouds      bool
12232                                 SunFogTint  color.NRGBA
12233                                 MoonFogTint color.NRGBA
12234                                 FogTintType string
12235
12236                                 //mt:if %s.Type == "skybox"
12237                                 Textures []Texture
12238
12239                                 //mt:if %s.Type == "regular"
12240                                 DaySky, DayHorizon,
12241                                 DawnSky, DawnHorizon,
12242                                 NightSky, NightHorizon,
12243                                 Indoor color.NRGBA
12244                         }))(obj)).Indoor
12245                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12246                 }
12247         }
12248 }
12249
12250 func (obj *ToCltOverrideDayNightRatio) serialize(w io.Writer) {
12251         {
12252                 x := (*(*(struct {
12253                         Override bool
12254                         Ratio    uint16
12255                 }))(obj)).Override
12256                 if x {
12257                         write8(w, 1)
12258                 } else {
12259                         write8(w, 0)
12260                 }
12261         }
12262         {
12263                 x := (*(*(struct {
12264                         Override bool
12265                         Ratio    uint16
12266                 }))(obj)).Ratio
12267                 write16(w, uint16(x))
12268         }
12269 }
12270
12271 func (obj *ToCltOverrideDayNightRatio) deserialize(r io.Reader) {
12272         {
12273                 p := &(*(*(struct {
12274                         Override bool
12275                         Ratio    uint16
12276                 }))(obj)).Override
12277                 switch n := read8(r); n {
12278                 case 0:
12279                         *p = false
12280                 case 1:
12281                         *p = true
12282                 default:
12283                         chk(fmt.Errorf("invalid bool: %d", n))
12284                 }
12285         }
12286         {
12287                 p := &(*(*(struct {
12288                         Override bool
12289                         Ratio    uint16
12290                 }))(obj)).Ratio
12291                 *p = read16(r)
12292         }
12293 }
12294
12295 func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
12296         for local198 := range (*(*(struct {
12297                 Idle, Walk, Dig, WalkDig [2]int32
12298                 Speed                    float32
12299         }))(obj)).Idle {
12300                 {
12301                         x := ((*(*(struct {
12302                                 Idle, Walk, Dig, WalkDig [2]int32
12303                                 Speed                    float32
12304                         }))(obj)).Idle)[local198]
12305                         write32(w, uint32(x))
12306                 }
12307         }
12308         for local199 := range (*(*(struct {
12309                 Idle, Walk, Dig, WalkDig [2]int32
12310                 Speed                    float32
12311         }))(obj)).Walk {
12312                 {
12313                         x := ((*(*(struct {
12314                                 Idle, Walk, Dig, WalkDig [2]int32
12315                                 Speed                    float32
12316                         }))(obj)).Walk)[local199]
12317                         write32(w, uint32(x))
12318                 }
12319         }
12320         for local200 := range (*(*(struct {
12321                 Idle, Walk, Dig, WalkDig [2]int32
12322                 Speed                    float32
12323         }))(obj)).Dig {
12324                 {
12325                         x := ((*(*(struct {
12326                                 Idle, Walk, Dig, WalkDig [2]int32
12327                                 Speed                    float32
12328                         }))(obj)).Dig)[local200]
12329                         write32(w, uint32(x))
12330                 }
12331         }
12332         for local201 := range (*(*(struct {
12333                 Idle, Walk, Dig, WalkDig [2]int32
12334                 Speed                    float32
12335         }))(obj)).WalkDig {
12336                 {
12337                         x := ((*(*(struct {
12338                                 Idle, Walk, Dig, WalkDig [2]int32
12339                                 Speed                    float32
12340                         }))(obj)).WalkDig)[local201]
12341                         write32(w, uint32(x))
12342                 }
12343         }
12344         {
12345                 x := (*(*(struct {
12346                         Idle, Walk, Dig, WalkDig [2]int32
12347                         Speed                    float32
12348                 }))(obj)).Speed
12349                 write32(w, math.Float32bits(x))
12350         }
12351 }
12352
12353 func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
12354         for local202 := range (*(*(struct {
12355                 Idle, Walk, Dig, WalkDig [2]int32
12356                 Speed                    float32
12357         }))(obj)).Idle {
12358                 {
12359                         p := &((*(*(struct {
12360                                 Idle, Walk, Dig, WalkDig [2]int32
12361                                 Speed                    float32
12362                         }))(obj)).Idle)[local202]
12363                         *p = int32(read32(r))
12364                 }
12365         }
12366         for local203 := range (*(*(struct {
12367                 Idle, Walk, Dig, WalkDig [2]int32
12368                 Speed                    float32
12369         }))(obj)).Walk {
12370                 {
12371                         p := &((*(*(struct {
12372                                 Idle, Walk, Dig, WalkDig [2]int32
12373                                 Speed                    float32
12374                         }))(obj)).Walk)[local203]
12375                         *p = int32(read32(r))
12376                 }
12377         }
12378         for local204 := range (*(*(struct {
12379                 Idle, Walk, Dig, WalkDig [2]int32
12380                 Speed                    float32
12381         }))(obj)).Dig {
12382                 {
12383                         p := &((*(*(struct {
12384                                 Idle, Walk, Dig, WalkDig [2]int32
12385                                 Speed                    float32
12386                         }))(obj)).Dig)[local204]
12387                         *p = int32(read32(r))
12388                 }
12389         }
12390         for local205 := range (*(*(struct {
12391                 Idle, Walk, Dig, WalkDig [2]int32
12392                 Speed                    float32
12393         }))(obj)).WalkDig {
12394                 {
12395                         p := &((*(*(struct {
12396                                 Idle, Walk, Dig, WalkDig [2]int32
12397                                 Speed                    float32
12398                         }))(obj)).WalkDig)[local205]
12399                         *p = int32(read32(r))
12400                 }
12401         }
12402         {
12403                 p := &(*(*(struct {
12404                         Idle, Walk, Dig, WalkDig [2]int32
12405                         Speed                    float32
12406                 }))(obj)).Speed
12407                 *p = math.Float32frombits(read32(r))
12408         }
12409 }
12410
12411 func (obj *ToCltEyeOffset) serialize(w io.Writer) {
12412         if err := pcall(func() {
12413                 ((*(*(struct {
12414                         First, Third Vec
12415                 }))(obj)).First).serialize(w)
12416         }); err != nil {
12417                 if err == io.EOF {
12418                         chk(io.EOF)
12419                 }
12420                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12421         }
12422         if err := pcall(func() {
12423                 ((*(*(struct {
12424                         First, Third Vec
12425                 }))(obj)).Third).serialize(w)
12426         }); err != nil {
12427                 if err == io.EOF {
12428                         chk(io.EOF)
12429                 }
12430                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12431         }
12432 }
12433
12434 func (obj *ToCltEyeOffset) deserialize(r io.Reader) {
12435         if err := pcall(func() {
12436                 ((*(*(struct {
12437                         First, Third Vec
12438                 }))(obj)).First).deserialize(r)
12439         }); err != nil {
12440                 if err == io.EOF {
12441                         chk(io.EOF)
12442                 }
12443                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12444         }
12445         if err := pcall(func() {
12446                 ((*(*(struct {
12447                         First, Third Vec
12448                 }))(obj)).Third).deserialize(r)
12449         }); err != nil {
12450                 if err == io.EOF {
12451                         chk(io.EOF)
12452                 }
12453                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12454         }
12455 }
12456
12457 func (obj *ToCltDelParticleSpawner) serialize(w io.Writer) {
12458         if err := pcall(func() {
12459                 ((*(*(struct {
12460                         ID ParticleSpawnerID
12461                 }))(obj)).ID).serialize(w)
12462         }); err != nil {
12463                 if err == io.EOF {
12464                         chk(io.EOF)
12465                 }
12466                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
12467         }
12468 }
12469
12470 func (obj *ToCltDelParticleSpawner) deserialize(r io.Reader) {
12471         if err := pcall(func() {
12472                 ((*(*(struct {
12473                         ID ParticleSpawnerID
12474                 }))(obj)).ID).deserialize(r)
12475         }); err != nil {
12476                 if err == io.EOF {
12477                         chk(io.EOF)
12478                 }
12479                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
12480         }
12481 }
12482
12483 func (obj *ToCltCloudParams) serialize(w io.Writer) {
12484         {
12485                 x := (*(*(struct {
12486                         Density      float32
12487                         DiffuseColor color.NRGBA
12488                         AmbientColor color.NRGBA
12489                         Height       float32
12490                         Thickness    float32
12491                         Speed        [2]float32
12492                 }))(obj)).Density
12493                 write32(w, math.Float32bits(x))
12494         }
12495         {
12496                 x := (*(*(struct {
12497                         Density      float32
12498                         DiffuseColor color.NRGBA
12499                         AmbientColor color.NRGBA
12500                         Height       float32
12501                         Thickness    float32
12502                         Speed        [2]float32
12503                 }))(obj)).DiffuseColor
12504                 w.Write([]byte{x.A, x.R, x.G, x.B})
12505         }
12506         {
12507                 x := (*(*(struct {
12508                         Density      float32
12509                         DiffuseColor color.NRGBA
12510                         AmbientColor color.NRGBA
12511                         Height       float32
12512                         Thickness    float32
12513                         Speed        [2]float32
12514                 }))(obj)).AmbientColor
12515                 w.Write([]byte{x.A, x.R, x.G, x.B})
12516         }
12517         {
12518                 x := (*(*(struct {
12519                         Density      float32
12520                         DiffuseColor color.NRGBA
12521                         AmbientColor color.NRGBA
12522                         Height       float32
12523                         Thickness    float32
12524                         Speed        [2]float32
12525                 }))(obj)).Height
12526                 write32(w, math.Float32bits(x))
12527         }
12528         {
12529                 x := (*(*(struct {
12530                         Density      float32
12531                         DiffuseColor color.NRGBA
12532                         AmbientColor color.NRGBA
12533                         Height       float32
12534                         Thickness    float32
12535                         Speed        [2]float32
12536                 }))(obj)).Thickness
12537                 write32(w, math.Float32bits(x))
12538         }
12539         for local206 := range (*(*(struct {
12540                 Density      float32
12541                 DiffuseColor color.NRGBA
12542                 AmbientColor color.NRGBA
12543                 Height       float32
12544                 Thickness    float32
12545                 Speed        [2]float32
12546         }))(obj)).Speed {
12547                 {
12548                         x := ((*(*(struct {
12549                                 Density      float32
12550                                 DiffuseColor color.NRGBA
12551                                 AmbientColor color.NRGBA
12552                                 Height       float32
12553                                 Thickness    float32
12554                                 Speed        [2]float32
12555                         }))(obj)).Speed)[local206]
12556                         write32(w, math.Float32bits(x))
12557                 }
12558         }
12559 }
12560
12561 func (obj *ToCltCloudParams) deserialize(r io.Reader) {
12562         {
12563                 p := &(*(*(struct {
12564                         Density      float32
12565                         DiffuseColor color.NRGBA
12566                         AmbientColor color.NRGBA
12567                         Height       float32
12568                         Thickness    float32
12569                         Speed        [2]float32
12570                 }))(obj)).Density
12571                 *p = math.Float32frombits(read32(r))
12572         }
12573         {
12574                 p := &(*(*(struct {
12575                         Density      float32
12576                         DiffuseColor color.NRGBA
12577                         AmbientColor color.NRGBA
12578                         Height       float32
12579                         Thickness    float32
12580                         Speed        [2]float32
12581                 }))(obj)).DiffuseColor
12582                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12583         }
12584         {
12585                 p := &(*(*(struct {
12586                         Density      float32
12587                         DiffuseColor color.NRGBA
12588                         AmbientColor color.NRGBA
12589                         Height       float32
12590                         Thickness    float32
12591                         Speed        [2]float32
12592                 }))(obj)).AmbientColor
12593                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12594         }
12595         {
12596                 p := &(*(*(struct {
12597                         Density      float32
12598                         DiffuseColor color.NRGBA
12599                         AmbientColor color.NRGBA
12600                         Height       float32
12601                         Thickness    float32
12602                         Speed        [2]float32
12603                 }))(obj)).Height
12604                 *p = math.Float32frombits(read32(r))
12605         }
12606         {
12607                 p := &(*(*(struct {
12608                         Density      float32
12609                         DiffuseColor color.NRGBA
12610                         AmbientColor color.NRGBA
12611                         Height       float32
12612                         Thickness    float32
12613                         Speed        [2]float32
12614                 }))(obj)).Thickness
12615                 *p = math.Float32frombits(read32(r))
12616         }
12617         for local207 := range (*(*(struct {
12618                 Density      float32
12619                 DiffuseColor color.NRGBA
12620                 AmbientColor color.NRGBA
12621                 Height       float32
12622                 Thickness    float32
12623                 Speed        [2]float32
12624         }))(obj)).Speed {
12625                 {
12626                         p := &((*(*(struct {
12627                                 Density      float32
12628                                 DiffuseColor color.NRGBA
12629                                 AmbientColor color.NRGBA
12630                                 Height       float32
12631                                 Thickness    float32
12632                                 Speed        [2]float32
12633                         }))(obj)).Speed)[local207]
12634                         *p = math.Float32frombits(read32(r))
12635                 }
12636         }
12637 }
12638
12639 func (obj *ToCltFadeSound) serialize(w io.Writer) {
12640         if err := pcall(func() {
12641                 ((*(*(struct {
12642                         ID   SoundID
12643                         Step float32
12644                         Gain float32
12645                 }))(obj)).ID).serialize(w)
12646         }); err != nil {
12647                 if err == io.EOF {
12648                         chk(io.EOF)
12649                 }
12650                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
12651         }
12652         {
12653                 x := (*(*(struct {
12654                         ID   SoundID
12655                         Step float32
12656                         Gain float32
12657                 }))(obj)).Step
12658                 write32(w, math.Float32bits(x))
12659         }
12660         {
12661                 x := (*(*(struct {
12662                         ID   SoundID
12663                         Step float32
12664                         Gain float32
12665                 }))(obj)).Gain
12666                 write32(w, math.Float32bits(x))
12667         }
12668 }
12669
12670 func (obj *ToCltFadeSound) deserialize(r io.Reader) {
12671         if err := pcall(func() {
12672                 ((*(*(struct {
12673                         ID   SoundID
12674                         Step float32
12675                         Gain float32
12676                 }))(obj)).ID).deserialize(r)
12677         }); err != nil {
12678                 if err == io.EOF {
12679                         chk(io.EOF)
12680                 }
12681                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
12682         }
12683         {
12684                 p := &(*(*(struct {
12685                         ID   SoundID
12686                         Step float32
12687                         Gain float32
12688                 }))(obj)).Step
12689                 *p = math.Float32frombits(read32(r))
12690         }
12691         {
12692                 p := &(*(*(struct {
12693                         ID   SoundID
12694                         Step float32
12695                         Gain float32
12696                 }))(obj)).Gain
12697                 *p = math.Float32frombits(read32(r))
12698         }
12699 }
12700
12701 func (obj *ToCltUpdatePlayerList) serialize(w io.Writer) {
12702         if err := pcall(func() {
12703                 ((*(*(struct {
12704                         Type    PlayerListUpdateType
12705                         Players []string
12706                 }))(obj)).Type).serialize(w)
12707         }); err != nil {
12708                 if err == io.EOF {
12709                         chk(io.EOF)
12710                 }
12711                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerListUpdateType", err))
12712         }
12713         if len(((*(*(struct {
12714                 Type    PlayerListUpdateType
12715                 Players []string
12716         }))(obj)).Players)) > math.MaxUint16 {
12717                 chk(ErrTooLong)
12718         }
12719         {
12720                 x := uint16(len(((*(*(struct {
12721                         Type    PlayerListUpdateType
12722                         Players []string
12723                 }))(obj)).Players)))
12724                 write16(w, uint16(x))
12725         }
12726         for local208 := range (*(*(struct {
12727                 Type    PlayerListUpdateType
12728                 Players []string
12729         }))(obj)).Players {
12730                 if len(([]byte(((*(*(struct {
12731                         Type    PlayerListUpdateType
12732                         Players []string
12733                 }))(obj)).Players)[local208]))) > math.MaxUint16 {
12734                         chk(ErrTooLong)
12735                 }
12736                 {
12737                         x := uint16(len(([]byte(((*(*(struct {
12738                                 Type    PlayerListUpdateType
12739                                 Players []string
12740                         }))(obj)).Players)[local208]))))
12741                         write16(w, uint16(x))
12742                 }
12743                 {
12744                         _, err := w.Write(([]byte(((*(*(struct {
12745                                 Type    PlayerListUpdateType
12746                                 Players []string
12747                         }))(obj)).Players)[local208]))[:])
12748                         chk(err)
12749                 }
12750         }
12751 }
12752
12753 func (obj *ToCltUpdatePlayerList) deserialize(r io.Reader) {
12754         if err := pcall(func() {
12755                 ((*(*(struct {
12756                         Type    PlayerListUpdateType
12757                         Players []string
12758                 }))(obj)).Type).deserialize(r)
12759         }); err != nil {
12760                 if err == io.EOF {
12761                         chk(io.EOF)
12762                 }
12763                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerListUpdateType", err))
12764         }
12765         var local209 uint16
12766         {
12767                 p := &local209
12768                 *p = read16(r)
12769         }
12770         ((*(*(struct {
12771                 Type    PlayerListUpdateType
12772                 Players []string
12773         }))(obj)).Players) = make([]string, local209)
12774         for local210 := range (*(*(struct {
12775                 Type    PlayerListUpdateType
12776                 Players []string
12777         }))(obj)).Players {
12778                 var local211 []uint8
12779                 var local212 uint16
12780                 {
12781                         p := &local212
12782                         *p = read16(r)
12783                 }
12784                 (local211) = make([]uint8, local212)
12785                 {
12786                         _, err := io.ReadFull(r, (local211)[:])
12787                         chk(err)
12788                 }
12789                 (((*(*(struct {
12790                         Type    PlayerListUpdateType
12791                         Players []string
12792                 }))(obj)).Players)[local210]) = string(local211)
12793         }
12794 }
12795
12796 func (obj *ToCltModChanMsg) serialize(w io.Writer) {
12797         if len(([]byte((*(*(struct {
12798                 Channel string
12799                 Sender  string
12800                 Msg     string
12801         }))(obj)).Channel))) > math.MaxUint16 {
12802                 chk(ErrTooLong)
12803         }
12804         {
12805                 x := uint16(len(([]byte((*(*(struct {
12806                         Channel string
12807                         Sender  string
12808                         Msg     string
12809                 }))(obj)).Channel))))
12810                 write16(w, uint16(x))
12811         }
12812         {
12813                 _, err := w.Write(([]byte((*(*(struct {
12814                         Channel string
12815                         Sender  string
12816                         Msg     string
12817                 }))(obj)).Channel))[:])
12818                 chk(err)
12819         }
12820         if len(([]byte((*(*(struct {
12821                 Channel string
12822                 Sender  string
12823                 Msg     string
12824         }))(obj)).Sender))) > math.MaxUint16 {
12825                 chk(ErrTooLong)
12826         }
12827         {
12828                 x := uint16(len(([]byte((*(*(struct {
12829                         Channel string
12830                         Sender  string
12831                         Msg     string
12832                 }))(obj)).Sender))))
12833                 write16(w, uint16(x))
12834         }
12835         {
12836                 _, err := w.Write(([]byte((*(*(struct {
12837                         Channel string
12838                         Sender  string
12839                         Msg     string
12840                 }))(obj)).Sender))[:])
12841                 chk(err)
12842         }
12843         if len(([]byte((*(*(struct {
12844                 Channel string
12845                 Sender  string
12846                 Msg     string
12847         }))(obj)).Msg))) > math.MaxUint16 {
12848                 chk(ErrTooLong)
12849         }
12850         {
12851                 x := uint16(len(([]byte((*(*(struct {
12852                         Channel string
12853                         Sender  string
12854                         Msg     string
12855                 }))(obj)).Msg))))
12856                 write16(w, uint16(x))
12857         }
12858         {
12859                 _, err := w.Write(([]byte((*(*(struct {
12860                         Channel string
12861                         Sender  string
12862                         Msg     string
12863                 }))(obj)).Msg))[:])
12864                 chk(err)
12865         }
12866 }
12867
12868 func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
12869         var local213 []uint8
12870         var local214 uint16
12871         {
12872                 p := &local214
12873                 *p = read16(r)
12874         }
12875         (local213) = make([]uint8, local214)
12876         {
12877                 _, err := io.ReadFull(r, (local213)[:])
12878                 chk(err)
12879         }
12880         ((*(*(struct {
12881                 Channel string
12882                 Sender  string
12883                 Msg     string
12884         }))(obj)).Channel) = string(local213)
12885         var local215 []uint8
12886         var local216 uint16
12887         {
12888                 p := &local216
12889                 *p = read16(r)
12890         }
12891         (local215) = make([]uint8, local216)
12892         {
12893                 _, err := io.ReadFull(r, (local215)[:])
12894                 chk(err)
12895         }
12896         ((*(*(struct {
12897                 Channel string
12898                 Sender  string
12899                 Msg     string
12900         }))(obj)).Sender) = string(local215)
12901         var local217 []uint8
12902         var local218 uint16
12903         {
12904                 p := &local218
12905                 *p = read16(r)
12906         }
12907         (local217) = make([]uint8, local218)
12908         {
12909                 _, err := io.ReadFull(r, (local217)[:])
12910                 chk(err)
12911         }
12912         ((*(*(struct {
12913                 Channel string
12914                 Sender  string
12915                 Msg     string
12916         }))(obj)).Msg) = string(local217)
12917 }
12918
12919 func (obj *ToCltModChanSig) serialize(w io.Writer) {
12920         if err := pcall(func() {
12921                 ((*(*(struct {
12922                         Signal  ModChanSig
12923                         Channel string
12924                 }))(obj)).Signal).serialize(w)
12925         }); err != nil {
12926                 if err == io.EOF {
12927                         chk(io.EOF)
12928                 }
12929                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ModChanSig", err))
12930         }
12931         if len(([]byte((*(*(struct {
12932                 Signal  ModChanSig
12933                 Channel string
12934         }))(obj)).Channel))) > math.MaxUint16 {
12935                 chk(ErrTooLong)
12936         }
12937         {
12938                 x := uint16(len(([]byte((*(*(struct {
12939                         Signal  ModChanSig
12940                         Channel string
12941                 }))(obj)).Channel))))
12942                 write16(w, uint16(x))
12943         }
12944         {
12945                 _, err := w.Write(([]byte((*(*(struct {
12946                         Signal  ModChanSig
12947                         Channel string
12948                 }))(obj)).Channel))[:])
12949                 chk(err)
12950         }
12951 }
12952
12953 func (obj *ToCltModChanSig) deserialize(r io.Reader) {
12954         if err := pcall(func() {
12955                 ((*(*(struct {
12956                         Signal  ModChanSig
12957                         Channel string
12958                 }))(obj)).Signal).deserialize(r)
12959         }); err != nil {
12960                 if err == io.EOF {
12961                         chk(io.EOF)
12962                 }
12963                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ModChanSig", err))
12964         }
12965         var local219 []uint8
12966         var local220 uint16
12967         {
12968                 p := &local220
12969                 *p = read16(r)
12970         }
12971         (local219) = make([]uint8, local220)
12972         {
12973                 _, err := io.ReadFull(r, (local219)[:])
12974                 chk(err)
12975         }
12976         ((*(*(struct {
12977                 Signal  ModChanSig
12978                 Channel string
12979         }))(obj)).Channel) = string(local219)
12980 }
12981
12982 func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
12983         {
12984                 ow := w
12985                 w := new(bytes.Buffer)
12986                 {
12987                         x := (*(*(struct {
12988                                 //mt:lenhdr 32
12989                                 Changed map[[3]int16]*NodeMeta
12990                         }))(obj)).Changed
12991                         {
12992                                 w := zlib.NewWriter(w)
12993                                 if x == nil {
12994                                         write8(w, 0)
12995                                 } else {
12996                                         write8(w, 2)
12997                                         if len(x) > math.MaxUint16 {
12998                                                 chk(ErrTooLong)
12999                                         }
13000                                         write16(w, uint16(len(x)))
13001                                         keys := make([][3]int16, 0, len(x))
13002                                         for key := range x {
13003                                                 keys = append(keys, key)
13004                                         }
13005                                         sort.Slice(keys, func(i, j int) bool {
13006                                                 p, q := keys[i], keys[j]
13007                                                 for i := range p {
13008                                                         switch {
13009                                                         case p[i] < q[i]:
13010                                                                 return true
13011                                                         case p[i] > q[i]:
13012                                                                 return false
13013                                                         }
13014                                                 }
13015                                                 return false
13016                                         })
13017                                         for _, key := range keys {
13018                                                 for _, n := range key {
13019                                                         write16(w, uint16(n))
13020                                                 }
13021                                                 chk(serialize(w, x[key]))
13022                                         }
13023                                 }
13024                                 chk(w.Close())
13025                         }
13026                 }
13027                 {
13028                         buf := w
13029                         w := ow
13030                         if len((buf.Bytes())) > math.MaxUint32 {
13031                                 chk(ErrTooLong)
13032                         }
13033                         {
13034                                 x := uint32(len((buf.Bytes())))
13035                                 write32(w, uint32(x))
13036                         }
13037                         {
13038                                 _, err := w.Write((buf.Bytes())[:])
13039                                 chk(err)
13040                         }
13041                 }
13042         }
13043 }
13044
13045 func (obj *ToCltNodeMetasChanged) deserialize(r io.Reader) {
13046         {
13047                 var n uint32
13048                 {
13049                         p := &n
13050                         *p = read32(r)
13051                 }
13052                 r := &io.LimitedReader{R: r, N: int64(n)}
13053                 {
13054                         p := &(*(*(struct {
13055                                 //mt:lenhdr 32
13056                                 Changed map[[3]int16]*NodeMeta
13057                         }))(obj)).Changed
13058                         {
13059                                 r, err := zlib.NewReader(byteReader{r})
13060                                 chk(err)
13061                                 switch ver := read8(r); ver {
13062                                 case 0:
13063                                         *p = nil
13064                                 case 2:
13065                                         n := read16(r)
13066                                         *p = make(map[[3]int16]*NodeMeta, n)
13067                                         for ; n > 0; n-- {
13068                                                 var pos [3]int16
13069                                                 for i := range pos {
13070                                                         pos[i] = int16(read16(r))
13071                                                 }
13072                                                 nm := new(NodeMeta)
13073                                                 chk(deserialize(r, nm))
13074                                                 (*p)[pos] = nm
13075                                         }
13076                                 default:
13077                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
13078                                 }
13079                                 chk(r.Close())
13080                         }
13081                 }
13082                 if r.N > 0 {
13083                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
13084                 }
13085         }
13086 }
13087
13088 func (obj *ToCltSunParams) serialize(w io.Writer) {
13089         {
13090                 x := (*(*(struct {
13091                         Visible bool
13092                         Texture
13093                         ToneMap Texture
13094                         Rise    Texture
13095                         Rising  bool
13096                         Size    float32
13097                 }))(obj)).Visible
13098                 if x {
13099                         write8(w, 1)
13100                 } else {
13101                         write8(w, 0)
13102                 }
13103         }
13104         if err := pcall(func() {
13105                 ((*(*(struct {
13106                         Visible bool
13107                         Texture
13108                         ToneMap Texture
13109                         Rise    Texture
13110                         Rising  bool
13111                         Size    float32
13112                 }))(obj)).Texture).serialize(w)
13113         }); err != nil {
13114                 if err == io.EOF {
13115                         chk(io.EOF)
13116                 }
13117                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13118         }
13119         if err := pcall(func() {
13120                 ((*(*(struct {
13121                         Visible bool
13122                         Texture
13123                         ToneMap Texture
13124                         Rise    Texture
13125                         Rising  bool
13126                         Size    float32
13127                 }))(obj)).ToneMap).serialize(w)
13128         }); err != nil {
13129                 if err == io.EOF {
13130                         chk(io.EOF)
13131                 }
13132                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13133         }
13134         if err := pcall(func() {
13135                 ((*(*(struct {
13136                         Visible bool
13137                         Texture
13138                         ToneMap Texture
13139                         Rise    Texture
13140                         Rising  bool
13141                         Size    float32
13142                 }))(obj)).Rise).serialize(w)
13143         }); err != nil {
13144                 if err == io.EOF {
13145                         chk(io.EOF)
13146                 }
13147                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13148         }
13149         {
13150                 x := (*(*(struct {
13151                         Visible bool
13152                         Texture
13153                         ToneMap Texture
13154                         Rise    Texture
13155                         Rising  bool
13156                         Size    float32
13157                 }))(obj)).Rising
13158                 if x {
13159                         write8(w, 1)
13160                 } else {
13161                         write8(w, 0)
13162                 }
13163         }
13164         {
13165                 x := (*(*(struct {
13166                         Visible bool
13167                         Texture
13168                         ToneMap Texture
13169                         Rise    Texture
13170                         Rising  bool
13171                         Size    float32
13172                 }))(obj)).Size
13173                 write32(w, math.Float32bits(x))
13174         }
13175 }
13176
13177 func (obj *ToCltSunParams) deserialize(r io.Reader) {
13178         {
13179                 p := &(*(*(struct {
13180                         Visible bool
13181                         Texture
13182                         ToneMap Texture
13183                         Rise    Texture
13184                         Rising  bool
13185                         Size    float32
13186                 }))(obj)).Visible
13187                 switch n := read8(r); n {
13188                 case 0:
13189                         *p = false
13190                 case 1:
13191                         *p = true
13192                 default:
13193                         chk(fmt.Errorf("invalid bool: %d", n))
13194                 }
13195         }
13196         if err := pcall(func() {
13197                 ((*(*(struct {
13198                         Visible bool
13199                         Texture
13200                         ToneMap Texture
13201                         Rise    Texture
13202                         Rising  bool
13203                         Size    float32
13204                 }))(obj)).Texture).deserialize(r)
13205         }); err != nil {
13206                 if err == io.EOF {
13207                         chk(io.EOF)
13208                 }
13209                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13210         }
13211         if err := pcall(func() {
13212                 ((*(*(struct {
13213                         Visible bool
13214                         Texture
13215                         ToneMap Texture
13216                         Rise    Texture
13217                         Rising  bool
13218                         Size    float32
13219                 }))(obj)).ToneMap).deserialize(r)
13220         }); err != nil {
13221                 if err == io.EOF {
13222                         chk(io.EOF)
13223                 }
13224                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13225         }
13226         if err := pcall(func() {
13227                 ((*(*(struct {
13228                         Visible bool
13229                         Texture
13230                         ToneMap Texture
13231                         Rise    Texture
13232                         Rising  bool
13233                         Size    float32
13234                 }))(obj)).Rise).deserialize(r)
13235         }); err != nil {
13236                 if err == io.EOF {
13237                         chk(io.EOF)
13238                 }
13239                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13240         }
13241         {
13242                 p := &(*(*(struct {
13243                         Visible bool
13244                         Texture
13245                         ToneMap Texture
13246                         Rise    Texture
13247                         Rising  bool
13248                         Size    float32
13249                 }))(obj)).Rising
13250                 switch n := read8(r); n {
13251                 case 0:
13252                         *p = false
13253                 case 1:
13254                         *p = true
13255                 default:
13256                         chk(fmt.Errorf("invalid bool: %d", n))
13257                 }
13258         }
13259         {
13260                 p := &(*(*(struct {
13261                         Visible bool
13262                         Texture
13263                         ToneMap Texture
13264                         Rise    Texture
13265                         Rising  bool
13266                         Size    float32
13267                 }))(obj)).Size
13268                 *p = math.Float32frombits(read32(r))
13269         }
13270 }
13271
13272 func (obj *ToCltMoonParams) serialize(w io.Writer) {
13273         {
13274                 x := (*(*(struct {
13275                         Visible bool
13276                         Texture
13277                         ToneMap Texture
13278                         Size    float32
13279                 }))(obj)).Visible
13280                 if x {
13281                         write8(w, 1)
13282                 } else {
13283                         write8(w, 0)
13284                 }
13285         }
13286         if err := pcall(func() {
13287                 ((*(*(struct {
13288                         Visible bool
13289                         Texture
13290                         ToneMap Texture
13291                         Size    float32
13292                 }))(obj)).Texture).serialize(w)
13293         }); err != nil {
13294                 if err == io.EOF {
13295                         chk(io.EOF)
13296                 }
13297                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13298         }
13299         if err := pcall(func() {
13300                 ((*(*(struct {
13301                         Visible bool
13302                         Texture
13303                         ToneMap Texture
13304                         Size    float32
13305                 }))(obj)).ToneMap).serialize(w)
13306         }); err != nil {
13307                 if err == io.EOF {
13308                         chk(io.EOF)
13309                 }
13310                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13311         }
13312         {
13313                 x := (*(*(struct {
13314                         Visible bool
13315                         Texture
13316                         ToneMap Texture
13317                         Size    float32
13318                 }))(obj)).Size
13319                 write32(w, math.Float32bits(x))
13320         }
13321 }
13322
13323 func (obj *ToCltMoonParams) deserialize(r io.Reader) {
13324         {
13325                 p := &(*(*(struct {
13326                         Visible bool
13327                         Texture
13328                         ToneMap Texture
13329                         Size    float32
13330                 }))(obj)).Visible
13331                 switch n := read8(r); n {
13332                 case 0:
13333                         *p = false
13334                 case 1:
13335                         *p = true
13336                 default:
13337                         chk(fmt.Errorf("invalid bool: %d", n))
13338                 }
13339         }
13340         if err := pcall(func() {
13341                 ((*(*(struct {
13342                         Visible bool
13343                         Texture
13344                         ToneMap Texture
13345                         Size    float32
13346                 }))(obj)).Texture).deserialize(r)
13347         }); err != nil {
13348                 if err == io.EOF {
13349                         chk(io.EOF)
13350                 }
13351                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13352         }
13353         if err := pcall(func() {
13354                 ((*(*(struct {
13355                         Visible bool
13356                         Texture
13357                         ToneMap Texture
13358                         Size    float32
13359                 }))(obj)).ToneMap).deserialize(r)
13360         }); err != nil {
13361                 if err == io.EOF {
13362                         chk(io.EOF)
13363                 }
13364                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13365         }
13366         {
13367                 p := &(*(*(struct {
13368                         Visible bool
13369                         Texture
13370                         ToneMap Texture
13371                         Size    float32
13372                 }))(obj)).Size
13373                 *p = math.Float32frombits(read32(r))
13374         }
13375 }
13376
13377 func (obj *ToCltStarParams) serialize(w io.Writer) {
13378         {
13379                 x := (*(*(struct {
13380                         Visible bool
13381                         Count   uint32
13382                         Color   color.NRGBA
13383                         Size    float32
13384                 }))(obj)).Visible
13385                 if x {
13386                         write8(w, 1)
13387                 } else {
13388                         write8(w, 0)
13389                 }
13390         }
13391         {
13392                 x := (*(*(struct {
13393                         Visible bool
13394                         Count   uint32
13395                         Color   color.NRGBA
13396                         Size    float32
13397                 }))(obj)).Count
13398                 write32(w, uint32(x))
13399         }
13400         {
13401                 x := (*(*(struct {
13402                         Visible bool
13403                         Count   uint32
13404                         Color   color.NRGBA
13405                         Size    float32
13406                 }))(obj)).Color
13407                 w.Write([]byte{x.A, x.R, x.G, x.B})
13408         }
13409         {
13410                 x := (*(*(struct {
13411                         Visible bool
13412                         Count   uint32
13413                         Color   color.NRGBA
13414                         Size    float32
13415                 }))(obj)).Size
13416                 write32(w, math.Float32bits(x))
13417         }
13418 }
13419
13420 func (obj *ToCltStarParams) deserialize(r io.Reader) {
13421         {
13422                 p := &(*(*(struct {
13423                         Visible bool
13424                         Count   uint32
13425                         Color   color.NRGBA
13426                         Size    float32
13427                 }))(obj)).Visible
13428                 switch n := read8(r); n {
13429                 case 0:
13430                         *p = false
13431                 case 1:
13432                         *p = true
13433                 default:
13434                         chk(fmt.Errorf("invalid bool: %d", n))
13435                 }
13436         }
13437         {
13438                 p := &(*(*(struct {
13439                         Visible bool
13440                         Count   uint32
13441                         Color   color.NRGBA
13442                         Size    float32
13443                 }))(obj)).Count
13444                 *p = read32(r)
13445         }
13446         {
13447                 p := &(*(*(struct {
13448                         Visible bool
13449                         Count   uint32
13450                         Color   color.NRGBA
13451                         Size    float32
13452                 }))(obj)).Color
13453                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13454         }
13455         {
13456                 p := &(*(*(struct {
13457                         Visible bool
13458                         Count   uint32
13459                         Color   color.NRGBA
13460                         Size    float32
13461                 }))(obj)).Size
13462                 *p = math.Float32frombits(read32(r))
13463         }
13464 }
13465
13466 func (obj *ToCltSRPBytesSaltB) serialize(w io.Writer) {
13467         if len(((*(*(struct {
13468                 Salt, B []byte
13469         }))(obj)).Salt)) > math.MaxUint16 {
13470                 chk(ErrTooLong)
13471         }
13472         {
13473                 x := uint16(len(((*(*(struct {
13474                         Salt, B []byte
13475                 }))(obj)).Salt)))
13476                 write16(w, uint16(x))
13477         }
13478         {
13479                 _, err := w.Write(((*(*(struct {
13480                         Salt, B []byte
13481                 }))(obj)).Salt)[:])
13482                 chk(err)
13483         }
13484         if len(((*(*(struct {
13485                 Salt, B []byte
13486         }))(obj)).B)) > math.MaxUint16 {
13487                 chk(ErrTooLong)
13488         }
13489         {
13490                 x := uint16(len(((*(*(struct {
13491                         Salt, B []byte
13492                 }))(obj)).B)))
13493                 write16(w, uint16(x))
13494         }
13495         {
13496                 _, err := w.Write(((*(*(struct {
13497                         Salt, B []byte
13498                 }))(obj)).B)[:])
13499                 chk(err)
13500         }
13501 }
13502
13503 func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
13504         var local221 uint16
13505         {
13506                 p := &local221
13507                 *p = read16(r)
13508         }
13509         ((*(*(struct {
13510                 Salt, B []byte
13511         }))(obj)).Salt) = make([]byte, local221)
13512         {
13513                 _, err := io.ReadFull(r, ((*(*(struct {
13514                         Salt, B []byte
13515                 }))(obj)).Salt)[:])
13516                 chk(err)
13517         }
13518         var local222 uint16
13519         {
13520                 p := &local222
13521                 *p = read16(r)
13522         }
13523         ((*(*(struct {
13524                 Salt, B []byte
13525         }))(obj)).B) = make([]byte, local222)
13526         {
13527                 _, err := io.ReadFull(r, ((*(*(struct {
13528                         Salt, B []byte
13529                 }))(obj)).B)[:])
13530                 chk(err)
13531         }
13532 }
13533
13534 func (obj *ToCltFormspecPrepend) serialize(w io.Writer) {
13535         if len(([]byte((*(*(struct {
13536                 Prepend string
13537         }))(obj)).Prepend))) > math.MaxUint16 {
13538                 chk(ErrTooLong)
13539         }
13540         {
13541                 x := uint16(len(([]byte((*(*(struct {
13542                         Prepend string
13543                 }))(obj)).Prepend))))
13544                 write16(w, uint16(x))
13545         }
13546         {
13547                 _, err := w.Write(([]byte((*(*(struct {
13548                         Prepend string
13549                 }))(obj)).Prepend))[:])
13550                 chk(err)
13551         }
13552 }
13553
13554 func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
13555         var local223 []uint8
13556         var local224 uint16
13557         {
13558                 p := &local224
13559                 *p = read16(r)
13560         }
13561         (local223) = make([]uint8, local224)
13562         {
13563                 _, err := io.ReadFull(r, (local223)[:])
13564                 chk(err)
13565         }
13566         ((*(*(struct {
13567                 Prepend string
13568         }))(obj)).Prepend) = string(local223)
13569 }
13570
13571 func (obj *AOCmdProps) serialize(w io.Writer) {
13572         if err := pcall(func() {
13573                 ((*(*(struct {
13574                         Props AOProps
13575                 }))(obj)).Props).serialize(w)
13576         }); err != nil {
13577                 if err == io.EOF {
13578                         chk(io.EOF)
13579                 }
13580                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOProps", err))
13581         }
13582 }
13583
13584 func (obj *AOCmdProps) deserialize(r io.Reader) {
13585         if err := pcall(func() {
13586                 ((*(*(struct {
13587                         Props AOProps
13588                 }))(obj)).Props).deserialize(r)
13589         }); err != nil {
13590                 if err == io.EOF {
13591                         chk(io.EOF)
13592                 }
13593                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOProps", err))
13594         }
13595 }
13596
13597 func (obj *AOCmdPos) serialize(w io.Writer) {
13598         if err := pcall(func() {
13599                 ((*(*(struct {
13600                         Pos AOPos
13601                 }))(obj)).Pos).serialize(w)
13602         }); err != nil {
13603                 if err == io.EOF {
13604                         chk(io.EOF)
13605                 }
13606                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPos", err))
13607         }
13608 }
13609
13610 func (obj *AOCmdPos) deserialize(r io.Reader) {
13611         if err := pcall(func() {
13612                 ((*(*(struct {
13613                         Pos AOPos
13614                 }))(obj)).Pos).deserialize(r)
13615         }); err != nil {
13616                 if err == io.EOF {
13617                         chk(io.EOF)
13618                 }
13619                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPos", err))
13620         }
13621 }
13622
13623 func (obj *AOCmdTextureMod) serialize(w io.Writer) {
13624         if err := pcall(func() {
13625                 ((*(*(struct {
13626                         Mod Texture // suffix
13627                 }))(obj)).Mod).serialize(w)
13628         }); err != nil {
13629                 if err == io.EOF {
13630                         chk(io.EOF)
13631                 }
13632                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13633         }
13634 }
13635
13636 func (obj *AOCmdTextureMod) deserialize(r io.Reader) {
13637         if err := pcall(func() {
13638                 ((*(*(struct {
13639                         Mod Texture // suffix
13640                 }))(obj)).Mod).deserialize(r)
13641         }); err != nil {
13642                 if err == io.EOF {
13643                         chk(io.EOF)
13644                 }
13645                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13646         }
13647 }
13648
13649 func (obj *AOCmdSprite) serialize(w io.Writer) {
13650         if err := pcall(func() {
13651                 ((*(*(struct {
13652                         Sprite AOSprite
13653                 }))(obj)).Sprite).serialize(w)
13654         }); err != nil {
13655                 if err == io.EOF {
13656                         chk(io.EOF)
13657                 }
13658                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOSprite", err))
13659         }
13660 }
13661
13662 func (obj *AOCmdSprite) deserialize(r io.Reader) {
13663         if err := pcall(func() {
13664                 ((*(*(struct {
13665                         Sprite AOSprite
13666                 }))(obj)).Sprite).deserialize(r)
13667         }); err != nil {
13668                 if err == io.EOF {
13669                         chk(io.EOF)
13670                 }
13671                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOSprite", err))
13672         }
13673 }
13674
13675 func (obj *AOCmdHP) serialize(w io.Writer) {
13676         {
13677                 x := (*(*(struct {
13678                         HP uint16
13679                 }))(obj)).HP
13680                 write16(w, uint16(x))
13681         }
13682 }
13683
13684 func (obj *AOCmdHP) deserialize(r io.Reader) {
13685         {
13686                 p := &(*(*(struct {
13687                         HP uint16
13688                 }))(obj)).HP
13689                 *p = read16(r)
13690         }
13691 }
13692
13693 func (obj *AOCmdArmorGroups) serialize(w io.Writer) {
13694         if len(((*(*(struct {
13695                 Armor []Group
13696         }))(obj)).Armor)) > math.MaxUint16 {
13697                 chk(ErrTooLong)
13698         }
13699         {
13700                 x := uint16(len(((*(*(struct {
13701                         Armor []Group
13702                 }))(obj)).Armor)))
13703                 write16(w, uint16(x))
13704         }
13705         for local225 := range (*(*(struct {
13706                 Armor []Group
13707         }))(obj)).Armor {
13708                 if err := pcall(func() {
13709                         (((*(*(struct {
13710                                 Armor []Group
13711                         }))(obj)).Armor)[local225]).serialize(w)
13712                 }); err != nil {
13713                         if err == io.EOF {
13714                                 chk(io.EOF)
13715                         }
13716                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
13717                 }
13718         }
13719 }
13720
13721 func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
13722         var local226 uint16
13723         {
13724                 p := &local226
13725                 *p = read16(r)
13726         }
13727         ((*(*(struct {
13728                 Armor []Group
13729         }))(obj)).Armor) = make([]Group, local226)
13730         for local227 := range (*(*(struct {
13731                 Armor []Group
13732         }))(obj)).Armor {
13733                 if err := pcall(func() {
13734                         (((*(*(struct {
13735                                 Armor []Group
13736                         }))(obj)).Armor)[local227]).deserialize(r)
13737                 }); err != nil {
13738                         if err == io.EOF {
13739                                 chk(io.EOF)
13740                         }
13741                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
13742                 }
13743         }
13744 }
13745
13746 func (obj *AOCmdAnim) serialize(w io.Writer) {
13747         if err := pcall(func() {
13748                 ((*(*(struct {
13749                         Anim AOAnim
13750                 }))(obj)).Anim).serialize(w)
13751         }); err != nil {
13752                 if err == io.EOF {
13753                         chk(io.EOF)
13754                 }
13755                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAnim", err))
13756         }
13757 }
13758
13759 func (obj *AOCmdAnim) deserialize(r io.Reader) {
13760         if err := pcall(func() {
13761                 ((*(*(struct {
13762                         Anim AOAnim
13763                 }))(obj)).Anim).deserialize(r)
13764         }); err != nil {
13765                 if err == io.EOF {
13766                         chk(io.EOF)
13767                 }
13768                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAnim", err))
13769         }
13770 }
13771
13772 func (obj *AOCmdBonePos) serialize(w io.Writer) {
13773         if len(([]byte((*(*(struct {
13774                 Bone string
13775                 Pos  AOBonePos
13776         }))(obj)).Bone))) > math.MaxUint16 {
13777                 chk(ErrTooLong)
13778         }
13779         {
13780                 x := uint16(len(([]byte((*(*(struct {
13781                         Bone string
13782                         Pos  AOBonePos
13783                 }))(obj)).Bone))))
13784                 write16(w, uint16(x))
13785         }
13786         {
13787                 _, err := w.Write(([]byte((*(*(struct {
13788                         Bone string
13789                         Pos  AOBonePos
13790                 }))(obj)).Bone))[:])
13791                 chk(err)
13792         }
13793         if err := pcall(func() {
13794                 ((*(*(struct {
13795                         Bone string
13796                         Pos  AOBonePos
13797                 }))(obj)).Pos).serialize(w)
13798         }); err != nil {
13799                 if err == io.EOF {
13800                         chk(io.EOF)
13801                 }
13802                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOBonePos", err))
13803         }
13804 }
13805
13806 func (obj *AOCmdBonePos) deserialize(r io.Reader) {
13807         var local228 []uint8
13808         var local229 uint16
13809         {
13810                 p := &local229
13811                 *p = read16(r)
13812         }
13813         (local228) = make([]uint8, local229)
13814         {
13815                 _, err := io.ReadFull(r, (local228)[:])
13816                 chk(err)
13817         }
13818         ((*(*(struct {
13819                 Bone string
13820                 Pos  AOBonePos
13821         }))(obj)).Bone) = string(local228)
13822         if err := pcall(func() {
13823                 ((*(*(struct {
13824                         Bone string
13825                         Pos  AOBonePos
13826                 }))(obj)).Pos).deserialize(r)
13827         }); err != nil {
13828                 if err == io.EOF {
13829                         chk(io.EOF)
13830                 }
13831                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOBonePos", err))
13832         }
13833 }
13834
13835 func (obj *AOCmdAttach) serialize(w io.Writer) {
13836         if err := pcall(func() {
13837                 ((*(*(struct {
13838                         Attach AOAttach
13839                 }))(obj)).Attach).serialize(w)
13840         }); err != nil {
13841                 if err == io.EOF {
13842                         chk(io.EOF)
13843                 }
13844                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAttach", err))
13845         }
13846 }
13847
13848 func (obj *AOCmdAttach) deserialize(r io.Reader) {
13849         if err := pcall(func() {
13850                 ((*(*(struct {
13851                         Attach AOAttach
13852                 }))(obj)).Attach).deserialize(r)
13853         }); err != nil {
13854                 if err == io.EOF {
13855                         chk(io.EOF)
13856                 }
13857                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAttach", err))
13858         }
13859 }
13860
13861 func (obj *AOCmdPhysOverride) serialize(w io.Writer) {
13862         if err := pcall(func() {
13863                 ((*(*(struct {
13864                         Phys AOPhysOverride
13865                 }))(obj)).Phys).serialize(w)
13866         }); err != nil {
13867                 if err == io.EOF {
13868                         chk(io.EOF)
13869                 }
13870                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPhysOverride", err))
13871         }
13872 }
13873
13874 func (obj *AOCmdPhysOverride) deserialize(r io.Reader) {
13875         if err := pcall(func() {
13876                 ((*(*(struct {
13877                         Phys AOPhysOverride
13878                 }))(obj)).Phys).deserialize(r)
13879         }); err != nil {
13880                 if err == io.EOF {
13881                         chk(io.EOF)
13882                 }
13883                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPhysOverride", err))
13884         }
13885 }
13886
13887 func (obj *AOCmdSpawnInfant) serialize(w io.Writer) {
13888         if err := pcall(func() {
13889                 ((*(*(struct {
13890                         ID AOID
13891                 }))(obj)).ID).serialize(w)
13892         }); err != nil {
13893                 if err == io.EOF {
13894                         chk(io.EOF)
13895                 }
13896                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
13897         }
13898         {
13899                 local230 := genericCAO
13900                 if err := pcall(func() {
13901                         (local230).serialize(w)
13902                 }); err != nil {
13903                         if err == io.EOF {
13904                                 chk(io.EOF)
13905                         }
13906                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
13907                 }
13908         }
13909 }
13910
13911 func (obj *AOCmdSpawnInfant) deserialize(r io.Reader) {
13912         if err := pcall(func() {
13913                 ((*(*(struct {
13914                         ID AOID
13915                 }))(obj)).ID).deserialize(r)
13916         }); err != nil {
13917                 if err == io.EOF {
13918                         chk(io.EOF)
13919                 }
13920                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
13921         }
13922         {
13923                 var local231 aoType
13924                 local232 := genericCAO
13925                 if err := pcall(func() {
13926                         (local231).deserialize(r)
13927                 }); err != nil {
13928                         if err == io.EOF {
13929                                 chk(io.EOF)
13930                         }
13931                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
13932                 }
13933                 if local231 != local232 {
13934                         chk(fmt.Errorf("const %v: %v", "genericCAO", local231))
13935                 }
13936         }
13937 }
13938
13939 func (obj *AOCmdAnimSpeed) serialize(w io.Writer) {
13940         {
13941                 x := (*(*(struct {
13942                         Speed float32
13943                 }))(obj)).Speed
13944                 write32(w, math.Float32bits(x))
13945         }
13946 }
13947
13948 func (obj *AOCmdAnimSpeed) deserialize(r io.Reader) {
13949         {
13950                 p := &(*(*(struct {
13951                         Speed float32
13952                 }))(obj)).Speed
13953                 *p = math.Float32frombits(read32(r))
13954         }
13955 }
13956
13957 func (obj *NodeMeta) serialize(w io.Writer) {
13958         if len(((*(*(struct {
13959                 //mt:len32
13960                 Fields []NodeMetaField
13961
13962                 Inv Inv
13963         }))(obj)).Fields)) > math.MaxUint32 {
13964                 chk(ErrTooLong)
13965         }
13966         {
13967                 x := uint32(len(((*(*(struct {
13968                         //mt:len32
13969                         Fields []NodeMetaField
13970
13971                         Inv Inv
13972                 }))(obj)).Fields)))
13973                 write32(w, uint32(x))
13974         }
13975         for local233 := range (*(*(struct {
13976                 //mt:len32
13977                 Fields []NodeMetaField
13978
13979                 Inv Inv
13980         }))(obj)).Fields {
13981                 if err := pcall(func() {
13982                         (((*(*(struct {
13983                                 //mt:len32
13984                                 Fields []NodeMetaField
13985
13986                                 Inv Inv
13987                         }))(obj)).Fields)[local233]).serialize(w)
13988                 }); err != nil {
13989                         if err == io.EOF {
13990                                 chk(io.EOF)
13991                         }
13992                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeMetaField", err))
13993                 }
13994         }
13995         chk(((*(*(struct {
13996                 //mt:len32
13997                 Fields []NodeMetaField
13998
13999                 Inv Inv
14000         }))(obj)).Inv).Serialize(w))
14001 }
14002
14003 func (obj *NodeMeta) deserialize(r io.Reader) {
14004         var local234 uint32
14005         {
14006                 p := &local234
14007                 *p = read32(r)
14008         }
14009         ((*(*(struct {
14010                 //mt:len32
14011                 Fields []NodeMetaField
14012
14013                 Inv Inv
14014         }))(obj)).Fields) = make([]NodeMetaField, local234)
14015         for local235 := range (*(*(struct {
14016                 //mt:len32
14017                 Fields []NodeMetaField
14018
14019                 Inv Inv
14020         }))(obj)).Fields {
14021                 if err := pcall(func() {
14022                         (((*(*(struct {
14023                                 //mt:len32
14024                                 Fields []NodeMetaField
14025
14026                                 Inv Inv
14027                         }))(obj)).Fields)[local235]).deserialize(r)
14028                 }); err != nil {
14029                         if err == io.EOF {
14030                                 chk(io.EOF)
14031                         }
14032                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeMetaField", err))
14033                 }
14034         }
14035         chk(((*(*(struct {
14036                 //mt:len32
14037                 Fields []NodeMetaField
14038
14039                 Inv Inv
14040         }))(obj)).Inv).Deserialize(r))
14041 }
14042
14043 func (obj *MinimapMode) serialize(w io.Writer) {
14044         if err := pcall(func() {
14045                 ((*(*(struct {
14046                         Type  MinimapType
14047                         Label string
14048                         Size  uint16
14049                         Texture
14050                         Scale uint16
14051                 }))(obj)).Type).serialize(w)
14052         }); err != nil {
14053                 if err == io.EOF {
14054                         chk(io.EOF)
14055                 }
14056                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MinimapType", err))
14057         }
14058         if len(([]byte((*(*(struct {
14059                 Type  MinimapType
14060                 Label string
14061                 Size  uint16
14062                 Texture
14063                 Scale uint16
14064         }))(obj)).Label))) > math.MaxUint16 {
14065                 chk(ErrTooLong)
14066         }
14067         {
14068                 x := uint16(len(([]byte((*(*(struct {
14069                         Type  MinimapType
14070                         Label string
14071                         Size  uint16
14072                         Texture
14073                         Scale uint16
14074                 }))(obj)).Label))))
14075                 write16(w, uint16(x))
14076         }
14077         {
14078                 _, err := w.Write(([]byte((*(*(struct {
14079                         Type  MinimapType
14080                         Label string
14081                         Size  uint16
14082                         Texture
14083                         Scale uint16
14084                 }))(obj)).Label))[:])
14085                 chk(err)
14086         }
14087         {
14088                 x := (*(*(struct {
14089                         Type  MinimapType
14090                         Label string
14091                         Size  uint16
14092                         Texture
14093                         Scale uint16
14094                 }))(obj)).Size
14095                 write16(w, uint16(x))
14096         }
14097         if err := pcall(func() {
14098                 ((*(*(struct {
14099                         Type  MinimapType
14100                         Label string
14101                         Size  uint16
14102                         Texture
14103                         Scale uint16
14104                 }))(obj)).Texture).serialize(w)
14105         }); err != nil {
14106                 if err == io.EOF {
14107                         chk(io.EOF)
14108                 }
14109                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
14110         }
14111         {
14112                 x := (*(*(struct {
14113                         Type  MinimapType
14114                         Label string
14115                         Size  uint16
14116                         Texture
14117                         Scale uint16
14118                 }))(obj)).Scale
14119                 write16(w, uint16(x))
14120         }
14121 }
14122
14123 func (obj *MinimapMode) deserialize(r io.Reader) {
14124         if err := pcall(func() {
14125                 ((*(*(struct {
14126                         Type  MinimapType
14127                         Label string
14128                         Size  uint16
14129                         Texture
14130                         Scale uint16
14131                 }))(obj)).Type).deserialize(r)
14132         }); err != nil {
14133                 if err == io.EOF {
14134                         chk(io.EOF)
14135                 }
14136                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MinimapType", err))
14137         }
14138         var local236 []uint8
14139         var local237 uint16
14140         {
14141                 p := &local237
14142                 *p = read16(r)
14143         }
14144         (local236) = make([]uint8, local237)
14145         {
14146                 _, err := io.ReadFull(r, (local236)[:])
14147                 chk(err)
14148         }
14149         ((*(*(struct {
14150                 Type  MinimapType
14151                 Label string
14152                 Size  uint16
14153                 Texture
14154                 Scale uint16
14155         }))(obj)).Label) = string(local236)
14156         {
14157                 p := &(*(*(struct {
14158                         Type  MinimapType
14159                         Label string
14160                         Size  uint16
14161                         Texture
14162                         Scale uint16
14163                 }))(obj)).Size
14164                 *p = read16(r)
14165         }
14166         if err := pcall(func() {
14167                 ((*(*(struct {
14168                         Type  MinimapType
14169                         Label string
14170                         Size  uint16
14171                         Texture
14172                         Scale uint16
14173                 }))(obj)).Texture).deserialize(r)
14174         }); err != nil {
14175                 if err == io.EOF {
14176                         chk(io.EOF)
14177                 }
14178                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
14179         }
14180         {
14181                 p := &(*(*(struct {
14182                         Type  MinimapType
14183                         Label string
14184                         Size  uint16
14185                         Texture
14186                         Scale uint16
14187                 }))(obj)).Scale
14188                 *p = read16(r)
14189         }
14190 }
14191
14192 func (obj *NodeDef) serialize(w io.Writer) {
14193         if err := pcall(func() {
14194                 ((*(*(struct {
14195                         Param0 Content
14196
14197                         Name   string
14198                         Groups []Group
14199
14200                         P1Type   Param1Type
14201                         P2Type   Param2Type
14202                         DrawType DrawType
14203
14204                         Mesh  string
14205                         Scale float32
14206                         //mt:const uint8(6)
14207                         Tiles        [6]TileDef
14208                         OverlayTiles [6]TileDef
14209                         //mt:const uint8(6)
14210                         SpecialTiles [6]TileDef
14211
14212                         Color   color.NRGBA
14213                         Palette Texture
14214
14215                         Waving       WaveType
14216                         ConnectSides uint8
14217                         ConnectTo    []Content
14218                         InsideTint   color.NRGBA
14219                         Level        uint8 // Must be < 128.
14220
14221                         Translucent bool // Sunlight is scattered and becomes normal light.
14222                         Transparent bool // Sunlight isn't scattered.
14223                         LightSrc    uint8
14224
14225                         GndContent   bool
14226                         Collides     bool
14227                         Pointable    bool
14228                         Diggable     bool
14229                         Climbable    bool
14230                         Replaceable  bool
14231                         OnRightClick bool
14232
14233                         DmgPerSec int32
14234
14235                         LiquidType   LiquidType
14236                         FlowingAlt   string
14237                         SrcAlt       string
14238                         Viscosity    uint8 // 0-7
14239                         LiqRenewable bool
14240                         FlowRange    uint8
14241                         DrownDmg     uint8
14242                         Floodable    bool
14243
14244                         DrawBox, ColBox, SelBox NodeBox
14245
14246                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14247
14248                         LegacyFaceDir bool
14249                         LegacyMounted bool
14250
14251                         DigPredict string
14252
14253                         MaxLvl uint8
14254
14255                         AlphaUse
14256
14257                         MoveResistance uint8
14258
14259                         LiquidMovePhysics bool
14260                 }))(obj)).Param0).serialize(w)
14261         }); err != nil {
14262                 if err == io.EOF {
14263                         chk(io.EOF)
14264                 }
14265                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
14266         }
14267         {
14268                 ow := w
14269                 w := new(bytes.Buffer)
14270                 {
14271                         local238 := uint8(13)
14272                         {
14273                                 x := local238
14274                                 write8(w, uint8(x))
14275                         }
14276                 }
14277                 if len(([]byte((*(*(struct {
14278                         Param0 Content
14279
14280                         Name   string
14281                         Groups []Group
14282
14283                         P1Type   Param1Type
14284                         P2Type   Param2Type
14285                         DrawType DrawType
14286
14287                         Mesh  string
14288                         Scale float32
14289                         //mt:const uint8(6)
14290                         Tiles        [6]TileDef
14291                         OverlayTiles [6]TileDef
14292                         //mt:const uint8(6)
14293                         SpecialTiles [6]TileDef
14294
14295                         Color   color.NRGBA
14296                         Palette Texture
14297
14298                         Waving       WaveType
14299                         ConnectSides uint8
14300                         ConnectTo    []Content
14301                         InsideTint   color.NRGBA
14302                         Level        uint8 // Must be < 128.
14303
14304                         Translucent bool // Sunlight is scattered and becomes normal light.
14305                         Transparent bool // Sunlight isn't scattered.
14306                         LightSrc    uint8
14307
14308                         GndContent   bool
14309                         Collides     bool
14310                         Pointable    bool
14311                         Diggable     bool
14312                         Climbable    bool
14313                         Replaceable  bool
14314                         OnRightClick bool
14315
14316                         DmgPerSec int32
14317
14318                         LiquidType   LiquidType
14319                         FlowingAlt   string
14320                         SrcAlt       string
14321                         Viscosity    uint8 // 0-7
14322                         LiqRenewable bool
14323                         FlowRange    uint8
14324                         DrownDmg     uint8
14325                         Floodable    bool
14326
14327                         DrawBox, ColBox, SelBox NodeBox
14328
14329                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14330
14331                         LegacyFaceDir bool
14332                         LegacyMounted bool
14333
14334                         DigPredict string
14335
14336                         MaxLvl uint8
14337
14338                         AlphaUse
14339
14340                         MoveResistance uint8
14341
14342                         LiquidMovePhysics bool
14343                 }))(obj)).Name))) > math.MaxUint16 {
14344                         chk(ErrTooLong)
14345                 }
14346                 {
14347                         x := uint16(len(([]byte((*(*(struct {
14348                                 Param0 Content
14349
14350                                 Name   string
14351                                 Groups []Group
14352
14353                                 P1Type   Param1Type
14354                                 P2Type   Param2Type
14355                                 DrawType DrawType
14356
14357                                 Mesh  string
14358                                 Scale float32
14359                                 //mt:const uint8(6)
14360                                 Tiles        [6]TileDef
14361                                 OverlayTiles [6]TileDef
14362                                 //mt:const uint8(6)
14363                                 SpecialTiles [6]TileDef
14364
14365                                 Color   color.NRGBA
14366                                 Palette Texture
14367
14368                                 Waving       WaveType
14369                                 ConnectSides uint8
14370                                 ConnectTo    []Content
14371                                 InsideTint   color.NRGBA
14372                                 Level        uint8 // Must be < 128.
14373
14374                                 Translucent bool // Sunlight is scattered and becomes normal light.
14375                                 Transparent bool // Sunlight isn't scattered.
14376                                 LightSrc    uint8
14377
14378                                 GndContent   bool
14379                                 Collides     bool
14380                                 Pointable    bool
14381                                 Diggable     bool
14382                                 Climbable    bool
14383                                 Replaceable  bool
14384                                 OnRightClick bool
14385
14386                                 DmgPerSec int32
14387
14388                                 LiquidType   LiquidType
14389                                 FlowingAlt   string
14390                                 SrcAlt       string
14391                                 Viscosity    uint8 // 0-7
14392                                 LiqRenewable bool
14393                                 FlowRange    uint8
14394                                 DrownDmg     uint8
14395                                 Floodable    bool
14396
14397                                 DrawBox, ColBox, SelBox NodeBox
14398
14399                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14400
14401                                 LegacyFaceDir bool
14402                                 LegacyMounted bool
14403
14404                                 DigPredict string
14405
14406                                 MaxLvl uint8
14407
14408                                 AlphaUse
14409
14410                                 MoveResistance uint8
14411
14412                                 LiquidMovePhysics bool
14413                         }))(obj)).Name))))
14414                         write16(w, uint16(x))
14415                 }
14416                 {
14417                         _, err := w.Write(([]byte((*(*(struct {
14418                                 Param0 Content
14419
14420                                 Name   string
14421                                 Groups []Group
14422
14423                                 P1Type   Param1Type
14424                                 P2Type   Param2Type
14425                                 DrawType DrawType
14426
14427                                 Mesh  string
14428                                 Scale float32
14429                                 //mt:const uint8(6)
14430                                 Tiles        [6]TileDef
14431                                 OverlayTiles [6]TileDef
14432                                 //mt:const uint8(6)
14433                                 SpecialTiles [6]TileDef
14434
14435                                 Color   color.NRGBA
14436                                 Palette Texture
14437
14438                                 Waving       WaveType
14439                                 ConnectSides uint8
14440                                 ConnectTo    []Content
14441                                 InsideTint   color.NRGBA
14442                                 Level        uint8 // Must be < 128.
14443
14444                                 Translucent bool // Sunlight is scattered and becomes normal light.
14445                                 Transparent bool // Sunlight isn't scattered.
14446                                 LightSrc    uint8
14447
14448                                 GndContent   bool
14449                                 Collides     bool
14450                                 Pointable    bool
14451                                 Diggable     bool
14452                                 Climbable    bool
14453                                 Replaceable  bool
14454                                 OnRightClick bool
14455
14456                                 DmgPerSec int32
14457
14458                                 LiquidType   LiquidType
14459                                 FlowingAlt   string
14460                                 SrcAlt       string
14461                                 Viscosity    uint8 // 0-7
14462                                 LiqRenewable bool
14463                                 FlowRange    uint8
14464                                 DrownDmg     uint8
14465                                 Floodable    bool
14466
14467                                 DrawBox, ColBox, SelBox NodeBox
14468
14469                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14470
14471                                 LegacyFaceDir bool
14472                                 LegacyMounted bool
14473
14474                                 DigPredict string
14475
14476                                 MaxLvl uint8
14477
14478                                 AlphaUse
14479
14480                                 MoveResistance uint8
14481
14482                                 LiquidMovePhysics bool
14483                         }))(obj)).Name))[:])
14484                         chk(err)
14485                 }
14486                 if len(((*(*(struct {
14487                         Param0 Content
14488
14489                         Name   string
14490                         Groups []Group
14491
14492                         P1Type   Param1Type
14493                         P2Type   Param2Type
14494                         DrawType DrawType
14495
14496                         Mesh  string
14497                         Scale float32
14498                         //mt:const uint8(6)
14499                         Tiles        [6]TileDef
14500                         OverlayTiles [6]TileDef
14501                         //mt:const uint8(6)
14502                         SpecialTiles [6]TileDef
14503
14504                         Color   color.NRGBA
14505                         Palette Texture
14506
14507                         Waving       WaveType
14508                         ConnectSides uint8
14509                         ConnectTo    []Content
14510                         InsideTint   color.NRGBA
14511                         Level        uint8 // Must be < 128.
14512
14513                         Translucent bool // Sunlight is scattered and becomes normal light.
14514                         Transparent bool // Sunlight isn't scattered.
14515                         LightSrc    uint8
14516
14517                         GndContent   bool
14518                         Collides     bool
14519                         Pointable    bool
14520                         Diggable     bool
14521                         Climbable    bool
14522                         Replaceable  bool
14523                         OnRightClick bool
14524
14525                         DmgPerSec int32
14526
14527                         LiquidType   LiquidType
14528                         FlowingAlt   string
14529                         SrcAlt       string
14530                         Viscosity    uint8 // 0-7
14531                         LiqRenewable bool
14532                         FlowRange    uint8
14533                         DrownDmg     uint8
14534                         Floodable    bool
14535
14536                         DrawBox, ColBox, SelBox NodeBox
14537
14538                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14539
14540                         LegacyFaceDir bool
14541                         LegacyMounted bool
14542
14543                         DigPredict string
14544
14545                         MaxLvl uint8
14546
14547                         AlphaUse
14548
14549                         MoveResistance uint8
14550
14551                         LiquidMovePhysics bool
14552                 }))(obj)).Groups)) > math.MaxUint16 {
14553                         chk(ErrTooLong)
14554                 }
14555                 {
14556                         x := uint16(len(((*(*(struct {
14557                                 Param0 Content
14558
14559                                 Name   string
14560                                 Groups []Group
14561
14562                                 P1Type   Param1Type
14563                                 P2Type   Param2Type
14564                                 DrawType DrawType
14565
14566                                 Mesh  string
14567                                 Scale float32
14568                                 //mt:const uint8(6)
14569                                 Tiles        [6]TileDef
14570                                 OverlayTiles [6]TileDef
14571                                 //mt:const uint8(6)
14572                                 SpecialTiles [6]TileDef
14573
14574                                 Color   color.NRGBA
14575                                 Palette Texture
14576
14577                                 Waving       WaveType
14578                                 ConnectSides uint8
14579                                 ConnectTo    []Content
14580                                 InsideTint   color.NRGBA
14581                                 Level        uint8 // Must be < 128.
14582
14583                                 Translucent bool // Sunlight is scattered and becomes normal light.
14584                                 Transparent bool // Sunlight isn't scattered.
14585                                 LightSrc    uint8
14586
14587                                 GndContent   bool
14588                                 Collides     bool
14589                                 Pointable    bool
14590                                 Diggable     bool
14591                                 Climbable    bool
14592                                 Replaceable  bool
14593                                 OnRightClick bool
14594
14595                                 DmgPerSec int32
14596
14597                                 LiquidType   LiquidType
14598                                 FlowingAlt   string
14599                                 SrcAlt       string
14600                                 Viscosity    uint8 // 0-7
14601                                 LiqRenewable bool
14602                                 FlowRange    uint8
14603                                 DrownDmg     uint8
14604                                 Floodable    bool
14605
14606                                 DrawBox, ColBox, SelBox NodeBox
14607
14608                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14609
14610                                 LegacyFaceDir bool
14611                                 LegacyMounted bool
14612
14613                                 DigPredict string
14614
14615                                 MaxLvl uint8
14616
14617                                 AlphaUse
14618
14619                                 MoveResistance uint8
14620
14621                                 LiquidMovePhysics bool
14622                         }))(obj)).Groups)))
14623                         write16(w, uint16(x))
14624                 }
14625                 for local239 := range (*(*(struct {
14626                         Param0 Content
14627
14628                         Name   string
14629                         Groups []Group
14630
14631                         P1Type   Param1Type
14632                         P2Type   Param2Type
14633                         DrawType DrawType
14634
14635                         Mesh  string
14636                         Scale float32
14637                         //mt:const uint8(6)
14638                         Tiles        [6]TileDef
14639                         OverlayTiles [6]TileDef
14640                         //mt:const uint8(6)
14641                         SpecialTiles [6]TileDef
14642
14643                         Color   color.NRGBA
14644                         Palette Texture
14645
14646                         Waving       WaveType
14647                         ConnectSides uint8
14648                         ConnectTo    []Content
14649                         InsideTint   color.NRGBA
14650                         Level        uint8 // Must be < 128.
14651
14652                         Translucent bool // Sunlight is scattered and becomes normal light.
14653                         Transparent bool // Sunlight isn't scattered.
14654                         LightSrc    uint8
14655
14656                         GndContent   bool
14657                         Collides     bool
14658                         Pointable    bool
14659                         Diggable     bool
14660                         Climbable    bool
14661                         Replaceable  bool
14662                         OnRightClick bool
14663
14664                         DmgPerSec int32
14665
14666                         LiquidType   LiquidType
14667                         FlowingAlt   string
14668                         SrcAlt       string
14669                         Viscosity    uint8 // 0-7
14670                         LiqRenewable bool
14671                         FlowRange    uint8
14672                         DrownDmg     uint8
14673                         Floodable    bool
14674
14675                         DrawBox, ColBox, SelBox NodeBox
14676
14677                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14678
14679                         LegacyFaceDir bool
14680                         LegacyMounted bool
14681
14682                         DigPredict string
14683
14684                         MaxLvl uint8
14685
14686                         AlphaUse
14687
14688                         MoveResistance uint8
14689
14690                         LiquidMovePhysics bool
14691                 }))(obj)).Groups {
14692                         if err := pcall(func() {
14693                                 (((*(*(struct {
14694                                         Param0 Content
14695
14696                                         Name   string
14697                                         Groups []Group
14698
14699                                         P1Type   Param1Type
14700                                         P2Type   Param2Type
14701                                         DrawType DrawType
14702
14703                                         Mesh  string
14704                                         Scale float32
14705                                         //mt:const uint8(6)
14706                                         Tiles        [6]TileDef
14707                                         OverlayTiles [6]TileDef
14708                                         //mt:const uint8(6)
14709                                         SpecialTiles [6]TileDef
14710
14711                                         Color   color.NRGBA
14712                                         Palette Texture
14713
14714                                         Waving       WaveType
14715                                         ConnectSides uint8
14716                                         ConnectTo    []Content
14717                                         InsideTint   color.NRGBA
14718                                         Level        uint8 // Must be < 128.
14719
14720                                         Translucent bool // Sunlight is scattered and becomes normal light.
14721                                         Transparent bool // Sunlight isn't scattered.
14722                                         LightSrc    uint8
14723
14724                                         GndContent   bool
14725                                         Collides     bool
14726                                         Pointable    bool
14727                                         Diggable     bool
14728                                         Climbable    bool
14729                                         Replaceable  bool
14730                                         OnRightClick bool
14731
14732                                         DmgPerSec int32
14733
14734                                         LiquidType   LiquidType
14735                                         FlowingAlt   string
14736                                         SrcAlt       string
14737                                         Viscosity    uint8 // 0-7
14738                                         LiqRenewable bool
14739                                         FlowRange    uint8
14740                                         DrownDmg     uint8
14741                                         Floodable    bool
14742
14743                                         DrawBox, ColBox, SelBox NodeBox
14744
14745                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14746
14747                                         LegacyFaceDir bool
14748                                         LegacyMounted bool
14749
14750                                         DigPredict string
14751
14752                                         MaxLvl uint8
14753
14754                                         AlphaUse
14755
14756                                         MoveResistance uint8
14757
14758                                         LiquidMovePhysics bool
14759                                 }))(obj)).Groups)[local239]).serialize(w)
14760                         }); err != nil {
14761                                 if err == io.EOF {
14762                                         chk(io.EOF)
14763                                 }
14764                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
14765                         }
14766                 }
14767                 if err := pcall(func() {
14768                         ((*(*(struct {
14769                                 Param0 Content
14770
14771                                 Name   string
14772                                 Groups []Group
14773
14774                                 P1Type   Param1Type
14775                                 P2Type   Param2Type
14776                                 DrawType DrawType
14777
14778                                 Mesh  string
14779                                 Scale float32
14780                                 //mt:const uint8(6)
14781                                 Tiles        [6]TileDef
14782                                 OverlayTiles [6]TileDef
14783                                 //mt:const uint8(6)
14784                                 SpecialTiles [6]TileDef
14785
14786                                 Color   color.NRGBA
14787                                 Palette Texture
14788
14789                                 Waving       WaveType
14790                                 ConnectSides uint8
14791                                 ConnectTo    []Content
14792                                 InsideTint   color.NRGBA
14793                                 Level        uint8 // Must be < 128.
14794
14795                                 Translucent bool // Sunlight is scattered and becomes normal light.
14796                                 Transparent bool // Sunlight isn't scattered.
14797                                 LightSrc    uint8
14798
14799                                 GndContent   bool
14800                                 Collides     bool
14801                                 Pointable    bool
14802                                 Diggable     bool
14803                                 Climbable    bool
14804                                 Replaceable  bool
14805                                 OnRightClick bool
14806
14807                                 DmgPerSec int32
14808
14809                                 LiquidType   LiquidType
14810                                 FlowingAlt   string
14811                                 SrcAlt       string
14812                                 Viscosity    uint8 // 0-7
14813                                 LiqRenewable bool
14814                                 FlowRange    uint8
14815                                 DrownDmg     uint8
14816                                 Floodable    bool
14817
14818                                 DrawBox, ColBox, SelBox NodeBox
14819
14820                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14821
14822                                 LegacyFaceDir bool
14823                                 LegacyMounted bool
14824
14825                                 DigPredict string
14826
14827                                 MaxLvl uint8
14828
14829                                 AlphaUse
14830
14831                                 MoveResistance uint8
14832
14833                                 LiquidMovePhysics bool
14834                         }))(obj)).P1Type).serialize(w)
14835                 }); err != nil {
14836                         if err == io.EOF {
14837                                 chk(io.EOF)
14838                         }
14839                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param1Type", err))
14840                 }
14841                 if err := pcall(func() {
14842                         ((*(*(struct {
14843                                 Param0 Content
14844
14845                                 Name   string
14846                                 Groups []Group
14847
14848                                 P1Type   Param1Type
14849                                 P2Type   Param2Type
14850                                 DrawType DrawType
14851
14852                                 Mesh  string
14853                                 Scale float32
14854                                 //mt:const uint8(6)
14855                                 Tiles        [6]TileDef
14856                                 OverlayTiles [6]TileDef
14857                                 //mt:const uint8(6)
14858                                 SpecialTiles [6]TileDef
14859
14860                                 Color   color.NRGBA
14861                                 Palette Texture
14862
14863                                 Waving       WaveType
14864                                 ConnectSides uint8
14865                                 ConnectTo    []Content
14866                                 InsideTint   color.NRGBA
14867                                 Level        uint8 // Must be < 128.
14868
14869                                 Translucent bool // Sunlight is scattered and becomes normal light.
14870                                 Transparent bool // Sunlight isn't scattered.
14871                                 LightSrc    uint8
14872
14873                                 GndContent   bool
14874                                 Collides     bool
14875                                 Pointable    bool
14876                                 Diggable     bool
14877                                 Climbable    bool
14878                                 Replaceable  bool
14879                                 OnRightClick bool
14880
14881                                 DmgPerSec int32
14882
14883                                 LiquidType   LiquidType
14884                                 FlowingAlt   string
14885                                 SrcAlt       string
14886                                 Viscosity    uint8 // 0-7
14887                                 LiqRenewable bool
14888                                 FlowRange    uint8
14889                                 DrownDmg     uint8
14890                                 Floodable    bool
14891
14892                                 DrawBox, ColBox, SelBox NodeBox
14893
14894                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14895
14896                                 LegacyFaceDir bool
14897                                 LegacyMounted bool
14898
14899                                 DigPredict string
14900
14901                                 MaxLvl uint8
14902
14903                                 AlphaUse
14904
14905                                 MoveResistance uint8
14906
14907                                 LiquidMovePhysics bool
14908                         }))(obj)).P2Type).serialize(w)
14909                 }); err != nil {
14910                         if err == io.EOF {
14911                                 chk(io.EOF)
14912                         }
14913                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param2Type", err))
14914                 }
14915                 if err := pcall(func() {
14916                         ((*(*(struct {
14917                                 Param0 Content
14918
14919                                 Name   string
14920                                 Groups []Group
14921
14922                                 P1Type   Param1Type
14923                                 P2Type   Param2Type
14924                                 DrawType DrawType
14925
14926                                 Mesh  string
14927                                 Scale float32
14928                                 //mt:const uint8(6)
14929                                 Tiles        [6]TileDef
14930                                 OverlayTiles [6]TileDef
14931                                 //mt:const uint8(6)
14932                                 SpecialTiles [6]TileDef
14933
14934                                 Color   color.NRGBA
14935                                 Palette Texture
14936
14937                                 Waving       WaveType
14938                                 ConnectSides uint8
14939                                 ConnectTo    []Content
14940                                 InsideTint   color.NRGBA
14941                                 Level        uint8 // Must be < 128.
14942
14943                                 Translucent bool // Sunlight is scattered and becomes normal light.
14944                                 Transparent bool // Sunlight isn't scattered.
14945                                 LightSrc    uint8
14946
14947                                 GndContent   bool
14948                                 Collides     bool
14949                                 Pointable    bool
14950                                 Diggable     bool
14951                                 Climbable    bool
14952                                 Replaceable  bool
14953                                 OnRightClick bool
14954
14955                                 DmgPerSec int32
14956
14957                                 LiquidType   LiquidType
14958                                 FlowingAlt   string
14959                                 SrcAlt       string
14960                                 Viscosity    uint8 // 0-7
14961                                 LiqRenewable bool
14962                                 FlowRange    uint8
14963                                 DrownDmg     uint8
14964                                 Floodable    bool
14965
14966                                 DrawBox, ColBox, SelBox NodeBox
14967
14968                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14969
14970                                 LegacyFaceDir bool
14971                                 LegacyMounted bool
14972
14973                                 DigPredict string
14974
14975                                 MaxLvl uint8
14976
14977                                 AlphaUse
14978
14979                                 MoveResistance uint8
14980
14981                                 LiquidMovePhysics bool
14982                         }))(obj)).DrawType).serialize(w)
14983                 }); err != nil {
14984                         if err == io.EOF {
14985                                 chk(io.EOF)
14986                         }
14987                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DrawType", err))
14988                 }
14989                 if len(([]byte((*(*(struct {
14990                         Param0 Content
14991
14992                         Name   string
14993                         Groups []Group
14994
14995                         P1Type   Param1Type
14996                         P2Type   Param2Type
14997                         DrawType DrawType
14998
14999                         Mesh  string
15000                         Scale float32
15001                         //mt:const uint8(6)
15002                         Tiles        [6]TileDef
15003                         OverlayTiles [6]TileDef
15004                         //mt:const uint8(6)
15005                         SpecialTiles [6]TileDef
15006
15007                         Color   color.NRGBA
15008                         Palette Texture
15009
15010                         Waving       WaveType
15011                         ConnectSides uint8
15012                         ConnectTo    []Content
15013                         InsideTint   color.NRGBA
15014                         Level        uint8 // Must be < 128.
15015
15016                         Translucent bool // Sunlight is scattered and becomes normal light.
15017                         Transparent bool // Sunlight isn't scattered.
15018                         LightSrc    uint8
15019
15020                         GndContent   bool
15021                         Collides     bool
15022                         Pointable    bool
15023                         Diggable     bool
15024                         Climbable    bool
15025                         Replaceable  bool
15026                         OnRightClick bool
15027
15028                         DmgPerSec int32
15029
15030                         LiquidType   LiquidType
15031                         FlowingAlt   string
15032                         SrcAlt       string
15033                         Viscosity    uint8 // 0-7
15034                         LiqRenewable bool
15035                         FlowRange    uint8
15036                         DrownDmg     uint8
15037                         Floodable    bool
15038
15039                         DrawBox, ColBox, SelBox NodeBox
15040
15041                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15042
15043                         LegacyFaceDir bool
15044                         LegacyMounted bool
15045
15046                         DigPredict string
15047
15048                         MaxLvl uint8
15049
15050                         AlphaUse
15051
15052                         MoveResistance uint8
15053
15054                         LiquidMovePhysics bool
15055                 }))(obj)).Mesh))) > math.MaxUint16 {
15056                         chk(ErrTooLong)
15057                 }
15058                 {
15059                         x := uint16(len(([]byte((*(*(struct {
15060                                 Param0 Content
15061
15062                                 Name   string
15063                                 Groups []Group
15064
15065                                 P1Type   Param1Type
15066                                 P2Type   Param2Type
15067                                 DrawType DrawType
15068
15069                                 Mesh  string
15070                                 Scale float32
15071                                 //mt:const uint8(6)
15072                                 Tiles        [6]TileDef
15073                                 OverlayTiles [6]TileDef
15074                                 //mt:const uint8(6)
15075                                 SpecialTiles [6]TileDef
15076
15077                                 Color   color.NRGBA
15078                                 Palette Texture
15079
15080                                 Waving       WaveType
15081                                 ConnectSides uint8
15082                                 ConnectTo    []Content
15083                                 InsideTint   color.NRGBA
15084                                 Level        uint8 // Must be < 128.
15085
15086                                 Translucent bool // Sunlight is scattered and becomes normal light.
15087                                 Transparent bool // Sunlight isn't scattered.
15088                                 LightSrc    uint8
15089
15090                                 GndContent   bool
15091                                 Collides     bool
15092                                 Pointable    bool
15093                                 Diggable     bool
15094                                 Climbable    bool
15095                                 Replaceable  bool
15096                                 OnRightClick bool
15097
15098                                 DmgPerSec int32
15099
15100                                 LiquidType   LiquidType
15101                                 FlowingAlt   string
15102                                 SrcAlt       string
15103                                 Viscosity    uint8 // 0-7
15104                                 LiqRenewable bool
15105                                 FlowRange    uint8
15106                                 DrownDmg     uint8
15107                                 Floodable    bool
15108
15109                                 DrawBox, ColBox, SelBox NodeBox
15110
15111                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15112
15113                                 LegacyFaceDir bool
15114                                 LegacyMounted bool
15115
15116                                 DigPredict string
15117
15118                                 MaxLvl uint8
15119
15120                                 AlphaUse
15121
15122                                 MoveResistance uint8
15123
15124                                 LiquidMovePhysics bool
15125                         }))(obj)).Mesh))))
15126                         write16(w, uint16(x))
15127                 }
15128                 {
15129                         _, err := w.Write(([]byte((*(*(struct {
15130                                 Param0 Content
15131
15132                                 Name   string
15133                                 Groups []Group
15134
15135                                 P1Type   Param1Type
15136                                 P2Type   Param2Type
15137                                 DrawType DrawType
15138
15139                                 Mesh  string
15140                                 Scale float32
15141                                 //mt:const uint8(6)
15142                                 Tiles        [6]TileDef
15143                                 OverlayTiles [6]TileDef
15144                                 //mt:const uint8(6)
15145                                 SpecialTiles [6]TileDef
15146
15147                                 Color   color.NRGBA
15148                                 Palette Texture
15149
15150                                 Waving       WaveType
15151                                 ConnectSides uint8
15152                                 ConnectTo    []Content
15153                                 InsideTint   color.NRGBA
15154                                 Level        uint8 // Must be < 128.
15155
15156                                 Translucent bool // Sunlight is scattered and becomes normal light.
15157                                 Transparent bool // Sunlight isn't scattered.
15158                                 LightSrc    uint8
15159
15160                                 GndContent   bool
15161                                 Collides     bool
15162                                 Pointable    bool
15163                                 Diggable     bool
15164                                 Climbable    bool
15165                                 Replaceable  bool
15166                                 OnRightClick bool
15167
15168                                 DmgPerSec int32
15169
15170                                 LiquidType   LiquidType
15171                                 FlowingAlt   string
15172                                 SrcAlt       string
15173                                 Viscosity    uint8 // 0-7
15174                                 LiqRenewable bool
15175                                 FlowRange    uint8
15176                                 DrownDmg     uint8
15177                                 Floodable    bool
15178
15179                                 DrawBox, ColBox, SelBox NodeBox
15180
15181                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15182
15183                                 LegacyFaceDir bool
15184                                 LegacyMounted bool
15185
15186                                 DigPredict string
15187
15188                                 MaxLvl uint8
15189
15190                                 AlphaUse
15191
15192                                 MoveResistance uint8
15193
15194                                 LiquidMovePhysics bool
15195                         }))(obj)).Mesh))[:])
15196                         chk(err)
15197                 }
15198                 {
15199                         x := (*(*(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
15262                                 MoveResistance uint8
15263
15264                                 LiquidMovePhysics bool
15265                         }))(obj)).Scale
15266                         write32(w, math.Float32bits(x))
15267                 }
15268                 {
15269                         local240 := uint8(6)
15270                         {
15271                                 x := local240
15272                                 write8(w, uint8(x))
15273                         }
15274                 }
15275                 for local241 := range (*(*(struct {
15276                         Param0 Content
15277
15278                         Name   string
15279                         Groups []Group
15280
15281                         P1Type   Param1Type
15282                         P2Type   Param2Type
15283                         DrawType DrawType
15284
15285                         Mesh  string
15286                         Scale float32
15287                         //mt:const uint8(6)
15288                         Tiles        [6]TileDef
15289                         OverlayTiles [6]TileDef
15290                         //mt:const uint8(6)
15291                         SpecialTiles [6]TileDef
15292
15293                         Color   color.NRGBA
15294                         Palette Texture
15295
15296                         Waving       WaveType
15297                         ConnectSides uint8
15298                         ConnectTo    []Content
15299                         InsideTint   color.NRGBA
15300                         Level        uint8 // Must be < 128.
15301
15302                         Translucent bool // Sunlight is scattered and becomes normal light.
15303                         Transparent bool // Sunlight isn't scattered.
15304                         LightSrc    uint8
15305
15306                         GndContent   bool
15307                         Collides     bool
15308                         Pointable    bool
15309                         Diggable     bool
15310                         Climbable    bool
15311                         Replaceable  bool
15312                         OnRightClick bool
15313
15314                         DmgPerSec int32
15315
15316                         LiquidType   LiquidType
15317                         FlowingAlt   string
15318                         SrcAlt       string
15319                         Viscosity    uint8 // 0-7
15320                         LiqRenewable bool
15321                         FlowRange    uint8
15322                         DrownDmg     uint8
15323                         Floodable    bool
15324
15325                         DrawBox, ColBox, SelBox NodeBox
15326
15327                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15328
15329                         LegacyFaceDir bool
15330                         LegacyMounted bool
15331
15332                         DigPredict string
15333
15334                         MaxLvl uint8
15335
15336                         AlphaUse
15337
15338                         MoveResistance uint8
15339
15340                         LiquidMovePhysics bool
15341                 }))(obj)).Tiles {
15342                         if err := pcall(func() {
15343                                 (((*(*(struct {
15344                                         Param0 Content
15345
15346                                         Name   string
15347                                         Groups []Group
15348
15349                                         P1Type   Param1Type
15350                                         P2Type   Param2Type
15351                                         DrawType DrawType
15352
15353                                         Mesh  string
15354                                         Scale float32
15355                                         //mt:const uint8(6)
15356                                         Tiles        [6]TileDef
15357                                         OverlayTiles [6]TileDef
15358                                         //mt:const uint8(6)
15359                                         SpecialTiles [6]TileDef
15360
15361                                         Color   color.NRGBA
15362                                         Palette Texture
15363
15364                                         Waving       WaveType
15365                                         ConnectSides uint8
15366                                         ConnectTo    []Content
15367                                         InsideTint   color.NRGBA
15368                                         Level        uint8 // Must be < 128.
15369
15370                                         Translucent bool // Sunlight is scattered and becomes normal light.
15371                                         Transparent bool // Sunlight isn't scattered.
15372                                         LightSrc    uint8
15373
15374                                         GndContent   bool
15375                                         Collides     bool
15376                                         Pointable    bool
15377                                         Diggable     bool
15378                                         Climbable    bool
15379                                         Replaceable  bool
15380                                         OnRightClick bool
15381
15382                                         DmgPerSec int32
15383
15384                                         LiquidType   LiquidType
15385                                         FlowingAlt   string
15386                                         SrcAlt       string
15387                                         Viscosity    uint8 // 0-7
15388                                         LiqRenewable bool
15389                                         FlowRange    uint8
15390                                         DrownDmg     uint8
15391                                         Floodable    bool
15392
15393                                         DrawBox, ColBox, SelBox NodeBox
15394
15395                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15396
15397                                         LegacyFaceDir bool
15398                                         LegacyMounted bool
15399
15400                                         DigPredict string
15401
15402                                         MaxLvl uint8
15403
15404                                         AlphaUse
15405
15406                                         MoveResistance uint8
15407
15408                                         LiquidMovePhysics bool
15409                                 }))(obj)).Tiles)[local241]).serialize(w)
15410                         }); err != nil {
15411                                 if err == io.EOF {
15412                                         chk(io.EOF)
15413                                 }
15414                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15415                         }
15416                 }
15417                 for local242 := range (*(*(struct {
15418                         Param0 Content
15419
15420                         Name   string
15421                         Groups []Group
15422
15423                         P1Type   Param1Type
15424                         P2Type   Param2Type
15425                         DrawType DrawType
15426
15427                         Mesh  string
15428                         Scale float32
15429                         //mt:const uint8(6)
15430                         Tiles        [6]TileDef
15431                         OverlayTiles [6]TileDef
15432                         //mt:const uint8(6)
15433                         SpecialTiles [6]TileDef
15434
15435                         Color   color.NRGBA
15436                         Palette Texture
15437
15438                         Waving       WaveType
15439                         ConnectSides uint8
15440                         ConnectTo    []Content
15441                         InsideTint   color.NRGBA
15442                         Level        uint8 // Must be < 128.
15443
15444                         Translucent bool // Sunlight is scattered and becomes normal light.
15445                         Transparent bool // Sunlight isn't scattered.
15446                         LightSrc    uint8
15447
15448                         GndContent   bool
15449                         Collides     bool
15450                         Pointable    bool
15451                         Diggable     bool
15452                         Climbable    bool
15453                         Replaceable  bool
15454                         OnRightClick bool
15455
15456                         DmgPerSec int32
15457
15458                         LiquidType   LiquidType
15459                         FlowingAlt   string
15460                         SrcAlt       string
15461                         Viscosity    uint8 // 0-7
15462                         LiqRenewable bool
15463                         FlowRange    uint8
15464                         DrownDmg     uint8
15465                         Floodable    bool
15466
15467                         DrawBox, ColBox, SelBox NodeBox
15468
15469                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15470
15471                         LegacyFaceDir bool
15472                         LegacyMounted bool
15473
15474                         DigPredict string
15475
15476                         MaxLvl uint8
15477
15478                         AlphaUse
15479
15480                         MoveResistance uint8
15481
15482                         LiquidMovePhysics bool
15483                 }))(obj)).OverlayTiles {
15484                         if err := pcall(func() {
15485                                 (((*(*(struct {
15486                                         Param0 Content
15487
15488                                         Name   string
15489                                         Groups []Group
15490
15491                                         P1Type   Param1Type
15492                                         P2Type   Param2Type
15493                                         DrawType DrawType
15494
15495                                         Mesh  string
15496                                         Scale float32
15497                                         //mt:const uint8(6)
15498                                         Tiles        [6]TileDef
15499                                         OverlayTiles [6]TileDef
15500                                         //mt:const uint8(6)
15501                                         SpecialTiles [6]TileDef
15502
15503                                         Color   color.NRGBA
15504                                         Palette Texture
15505
15506                                         Waving       WaveType
15507                                         ConnectSides uint8
15508                                         ConnectTo    []Content
15509                                         InsideTint   color.NRGBA
15510                                         Level        uint8 // Must be < 128.
15511
15512                                         Translucent bool // Sunlight is scattered and becomes normal light.
15513                                         Transparent bool // Sunlight isn't scattered.
15514                                         LightSrc    uint8
15515
15516                                         GndContent   bool
15517                                         Collides     bool
15518                                         Pointable    bool
15519                                         Diggable     bool
15520                                         Climbable    bool
15521                                         Replaceable  bool
15522                                         OnRightClick bool
15523
15524                                         DmgPerSec int32
15525
15526                                         LiquidType   LiquidType
15527                                         FlowingAlt   string
15528                                         SrcAlt       string
15529                                         Viscosity    uint8 // 0-7
15530                                         LiqRenewable bool
15531                                         FlowRange    uint8
15532                                         DrownDmg     uint8
15533                                         Floodable    bool
15534
15535                                         DrawBox, ColBox, SelBox NodeBox
15536
15537                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15538
15539                                         LegacyFaceDir bool
15540                                         LegacyMounted bool
15541
15542                                         DigPredict string
15543
15544                                         MaxLvl uint8
15545
15546                                         AlphaUse
15547
15548                                         MoveResistance uint8
15549
15550                                         LiquidMovePhysics bool
15551                                 }))(obj)).OverlayTiles)[local242]).serialize(w)
15552                         }); err != nil {
15553                                 if err == io.EOF {
15554                                         chk(io.EOF)
15555                                 }
15556                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15557                         }
15558                 }
15559                 {
15560                         local243 := uint8(6)
15561                         {
15562                                 x := local243
15563                                 write8(w, uint8(x))
15564                         }
15565                 }
15566                 for local244 := range (*(*(struct {
15567                         Param0 Content
15568
15569                         Name   string
15570                         Groups []Group
15571
15572                         P1Type   Param1Type
15573                         P2Type   Param2Type
15574                         DrawType DrawType
15575
15576                         Mesh  string
15577                         Scale float32
15578                         //mt:const uint8(6)
15579                         Tiles        [6]TileDef
15580                         OverlayTiles [6]TileDef
15581                         //mt:const uint8(6)
15582                         SpecialTiles [6]TileDef
15583
15584                         Color   color.NRGBA
15585                         Palette Texture
15586
15587                         Waving       WaveType
15588                         ConnectSides uint8
15589                         ConnectTo    []Content
15590                         InsideTint   color.NRGBA
15591                         Level        uint8 // Must be < 128.
15592
15593                         Translucent bool // Sunlight is scattered and becomes normal light.
15594                         Transparent bool // Sunlight isn't scattered.
15595                         LightSrc    uint8
15596
15597                         GndContent   bool
15598                         Collides     bool
15599                         Pointable    bool
15600                         Diggable     bool
15601                         Climbable    bool
15602                         Replaceable  bool
15603                         OnRightClick bool
15604
15605                         DmgPerSec int32
15606
15607                         LiquidType   LiquidType
15608                         FlowingAlt   string
15609                         SrcAlt       string
15610                         Viscosity    uint8 // 0-7
15611                         LiqRenewable bool
15612                         FlowRange    uint8
15613                         DrownDmg     uint8
15614                         Floodable    bool
15615
15616                         DrawBox, ColBox, SelBox NodeBox
15617
15618                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15619
15620                         LegacyFaceDir bool
15621                         LegacyMounted bool
15622
15623                         DigPredict string
15624
15625                         MaxLvl uint8
15626
15627                         AlphaUse
15628
15629                         MoveResistance uint8
15630
15631                         LiquidMovePhysics bool
15632                 }))(obj)).SpecialTiles {
15633                         if err := pcall(func() {
15634                                 (((*(*(struct {
15635                                         Param0 Content
15636
15637                                         Name   string
15638                                         Groups []Group
15639
15640                                         P1Type   Param1Type
15641                                         P2Type   Param2Type
15642                                         DrawType DrawType
15643
15644                                         Mesh  string
15645                                         Scale float32
15646                                         //mt:const uint8(6)
15647                                         Tiles        [6]TileDef
15648                                         OverlayTiles [6]TileDef
15649                                         //mt:const uint8(6)
15650                                         SpecialTiles [6]TileDef
15651
15652                                         Color   color.NRGBA
15653                                         Palette Texture
15654
15655                                         Waving       WaveType
15656                                         ConnectSides uint8
15657                                         ConnectTo    []Content
15658                                         InsideTint   color.NRGBA
15659                                         Level        uint8 // Must be < 128.
15660
15661                                         Translucent bool // Sunlight is scattered and becomes normal light.
15662                                         Transparent bool // Sunlight isn't scattered.
15663                                         LightSrc    uint8
15664
15665                                         GndContent   bool
15666                                         Collides     bool
15667                                         Pointable    bool
15668                                         Diggable     bool
15669                                         Climbable    bool
15670                                         Replaceable  bool
15671                                         OnRightClick bool
15672
15673                                         DmgPerSec int32
15674
15675                                         LiquidType   LiquidType
15676                                         FlowingAlt   string
15677                                         SrcAlt       string
15678                                         Viscosity    uint8 // 0-7
15679                                         LiqRenewable bool
15680                                         FlowRange    uint8
15681                                         DrownDmg     uint8
15682                                         Floodable    bool
15683
15684                                         DrawBox, ColBox, SelBox NodeBox
15685
15686                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15687
15688                                         LegacyFaceDir bool
15689                                         LegacyMounted bool
15690
15691                                         DigPredict string
15692
15693                                         MaxLvl uint8
15694
15695                                         AlphaUse
15696
15697                                         MoveResistance uint8
15698
15699                                         LiquidMovePhysics bool
15700                                 }))(obj)).SpecialTiles)[local244]).serialize(w)
15701                         }); err != nil {
15702                                 if err == io.EOF {
15703                                         chk(io.EOF)
15704                                 }
15705                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15706                         }
15707                 }
15708                 {
15709                         x := (*(*(struct {
15710                                 Param0 Content
15711
15712                                 Name   string
15713                                 Groups []Group
15714
15715                                 P1Type   Param1Type
15716                                 P2Type   Param2Type
15717                                 DrawType DrawType
15718
15719                                 Mesh  string
15720                                 Scale float32
15721                                 //mt:const uint8(6)
15722                                 Tiles        [6]TileDef
15723                                 OverlayTiles [6]TileDef
15724                                 //mt:const uint8(6)
15725                                 SpecialTiles [6]TileDef
15726
15727                                 Color   color.NRGBA
15728                                 Palette Texture
15729
15730                                 Waving       WaveType
15731                                 ConnectSides uint8
15732                                 ConnectTo    []Content
15733                                 InsideTint   color.NRGBA
15734                                 Level        uint8 // Must be < 128.
15735
15736                                 Translucent bool // Sunlight is scattered and becomes normal light.
15737                                 Transparent bool // Sunlight isn't scattered.
15738                                 LightSrc    uint8
15739
15740                                 GndContent   bool
15741                                 Collides     bool
15742                                 Pointable    bool
15743                                 Diggable     bool
15744                                 Climbable    bool
15745                                 Replaceable  bool
15746                                 OnRightClick bool
15747
15748                                 DmgPerSec int32
15749
15750                                 LiquidType   LiquidType
15751                                 FlowingAlt   string
15752                                 SrcAlt       string
15753                                 Viscosity    uint8 // 0-7
15754                                 LiqRenewable bool
15755                                 FlowRange    uint8
15756                                 DrownDmg     uint8
15757                                 Floodable    bool
15758
15759                                 DrawBox, ColBox, SelBox NodeBox
15760
15761                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15762
15763                                 LegacyFaceDir bool
15764                                 LegacyMounted bool
15765
15766                                 DigPredict string
15767
15768                                 MaxLvl uint8
15769
15770                                 AlphaUse
15771
15772                                 MoveResistance uint8
15773
15774                                 LiquidMovePhysics bool
15775                         }))(obj)).Color
15776                         w.Write([]byte{x.A, x.R, x.G, x.B})
15777                 }
15778                 if err := pcall(func() {
15779                         ((*(*(struct {
15780                                 Param0 Content
15781
15782                                 Name   string
15783                                 Groups []Group
15784
15785                                 P1Type   Param1Type
15786                                 P2Type   Param2Type
15787                                 DrawType DrawType
15788
15789                                 Mesh  string
15790                                 Scale float32
15791                                 //mt:const uint8(6)
15792                                 Tiles        [6]TileDef
15793                                 OverlayTiles [6]TileDef
15794                                 //mt:const uint8(6)
15795                                 SpecialTiles [6]TileDef
15796
15797                                 Color   color.NRGBA
15798                                 Palette Texture
15799
15800                                 Waving       WaveType
15801                                 ConnectSides uint8
15802                                 ConnectTo    []Content
15803                                 InsideTint   color.NRGBA
15804                                 Level        uint8 // Must be < 128.
15805
15806                                 Translucent bool // Sunlight is scattered and becomes normal light.
15807                                 Transparent bool // Sunlight isn't scattered.
15808                                 LightSrc    uint8
15809
15810                                 GndContent   bool
15811                                 Collides     bool
15812                                 Pointable    bool
15813                                 Diggable     bool
15814                                 Climbable    bool
15815                                 Replaceable  bool
15816                                 OnRightClick bool
15817
15818                                 DmgPerSec int32
15819
15820                                 LiquidType   LiquidType
15821                                 FlowingAlt   string
15822                                 SrcAlt       string
15823                                 Viscosity    uint8 // 0-7
15824                                 LiqRenewable bool
15825                                 FlowRange    uint8
15826                                 DrownDmg     uint8
15827                                 Floodable    bool
15828
15829                                 DrawBox, ColBox, SelBox NodeBox
15830
15831                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15832
15833                                 LegacyFaceDir bool
15834                                 LegacyMounted bool
15835
15836                                 DigPredict string
15837
15838                                 MaxLvl uint8
15839
15840                                 AlphaUse
15841
15842                                 MoveResistance uint8
15843
15844                                 LiquidMovePhysics bool
15845                         }))(obj)).Palette).serialize(w)
15846                 }); err != nil {
15847                         if err == io.EOF {
15848                                 chk(io.EOF)
15849                         }
15850                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
15851                 }
15852                 if err := pcall(func() {
15853                         ((*(*(struct {
15854                                 Param0 Content
15855
15856                                 Name   string
15857                                 Groups []Group
15858
15859                                 P1Type   Param1Type
15860                                 P2Type   Param2Type
15861                                 DrawType DrawType
15862
15863                                 Mesh  string
15864                                 Scale float32
15865                                 //mt:const uint8(6)
15866                                 Tiles        [6]TileDef
15867                                 OverlayTiles [6]TileDef
15868                                 //mt:const uint8(6)
15869                                 SpecialTiles [6]TileDef
15870
15871                                 Color   color.NRGBA
15872                                 Palette Texture
15873
15874                                 Waving       WaveType
15875                                 ConnectSides uint8
15876                                 ConnectTo    []Content
15877                                 InsideTint   color.NRGBA
15878                                 Level        uint8 // Must be < 128.
15879
15880                                 Translucent bool // Sunlight is scattered and becomes normal light.
15881                                 Transparent bool // Sunlight isn't scattered.
15882                                 LightSrc    uint8
15883
15884                                 GndContent   bool
15885                                 Collides     bool
15886                                 Pointable    bool
15887                                 Diggable     bool
15888                                 Climbable    bool
15889                                 Replaceable  bool
15890                                 OnRightClick bool
15891
15892                                 DmgPerSec int32
15893
15894                                 LiquidType   LiquidType
15895                                 FlowingAlt   string
15896                                 SrcAlt       string
15897                                 Viscosity    uint8 // 0-7
15898                                 LiqRenewable bool
15899                                 FlowRange    uint8
15900                                 DrownDmg     uint8
15901                                 Floodable    bool
15902
15903                                 DrawBox, ColBox, SelBox NodeBox
15904
15905                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15906
15907                                 LegacyFaceDir bool
15908                                 LegacyMounted bool
15909
15910                                 DigPredict string
15911
15912                                 MaxLvl uint8
15913
15914                                 AlphaUse
15915
15916                                 MoveResistance uint8
15917
15918                                 LiquidMovePhysics bool
15919                         }))(obj)).Waving).serialize(w)
15920                 }); err != nil {
15921                         if err == io.EOF {
15922                                 chk(io.EOF)
15923                         }
15924                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.WaveType", err))
15925                 }
15926                 {
15927                         x := (*(*(struct {
15928                                 Param0 Content
15929
15930                                 Name   string
15931                                 Groups []Group
15932
15933                                 P1Type   Param1Type
15934                                 P2Type   Param2Type
15935                                 DrawType DrawType
15936
15937                                 Mesh  string
15938                                 Scale float32
15939                                 //mt:const uint8(6)
15940                                 Tiles        [6]TileDef
15941                                 OverlayTiles [6]TileDef
15942                                 //mt:const uint8(6)
15943                                 SpecialTiles [6]TileDef
15944
15945                                 Color   color.NRGBA
15946                                 Palette Texture
15947
15948                                 Waving       WaveType
15949                                 ConnectSides uint8
15950                                 ConnectTo    []Content
15951                                 InsideTint   color.NRGBA
15952                                 Level        uint8 // Must be < 128.
15953
15954                                 Translucent bool // Sunlight is scattered and becomes normal light.
15955                                 Transparent bool // Sunlight isn't scattered.
15956                                 LightSrc    uint8
15957
15958                                 GndContent   bool
15959                                 Collides     bool
15960                                 Pointable    bool
15961                                 Diggable     bool
15962                                 Climbable    bool
15963                                 Replaceable  bool
15964                                 OnRightClick bool
15965
15966                                 DmgPerSec int32
15967
15968                                 LiquidType   LiquidType
15969                                 FlowingAlt   string
15970                                 SrcAlt       string
15971                                 Viscosity    uint8 // 0-7
15972                                 LiqRenewable bool
15973                                 FlowRange    uint8
15974                                 DrownDmg     uint8
15975                                 Floodable    bool
15976
15977                                 DrawBox, ColBox, SelBox NodeBox
15978
15979                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15980
15981                                 LegacyFaceDir bool
15982                                 LegacyMounted bool
15983
15984                                 DigPredict string
15985
15986                                 MaxLvl uint8
15987
15988                                 AlphaUse
15989
15990                                 MoveResistance uint8
15991
15992                                 LiquidMovePhysics bool
15993                         }))(obj)).ConnectSides
15994                         write8(w, uint8(x))
15995                 }
15996                 if len(((*(*(struct {
15997                         Param0 Content
15998
15999                         Name   string
16000                         Groups []Group
16001
16002                         P1Type   Param1Type
16003                         P2Type   Param2Type
16004                         DrawType DrawType
16005
16006                         Mesh  string
16007                         Scale float32
16008                         //mt:const uint8(6)
16009                         Tiles        [6]TileDef
16010                         OverlayTiles [6]TileDef
16011                         //mt:const uint8(6)
16012                         SpecialTiles [6]TileDef
16013
16014                         Color   color.NRGBA
16015                         Palette Texture
16016
16017                         Waving       WaveType
16018                         ConnectSides uint8
16019                         ConnectTo    []Content
16020                         InsideTint   color.NRGBA
16021                         Level        uint8 // Must be < 128.
16022
16023                         Translucent bool // Sunlight is scattered and becomes normal light.
16024                         Transparent bool // Sunlight isn't scattered.
16025                         LightSrc    uint8
16026
16027                         GndContent   bool
16028                         Collides     bool
16029                         Pointable    bool
16030                         Diggable     bool
16031                         Climbable    bool
16032                         Replaceable  bool
16033                         OnRightClick bool
16034
16035                         DmgPerSec int32
16036
16037                         LiquidType   LiquidType
16038                         FlowingAlt   string
16039                         SrcAlt       string
16040                         Viscosity    uint8 // 0-7
16041                         LiqRenewable bool
16042                         FlowRange    uint8
16043                         DrownDmg     uint8
16044                         Floodable    bool
16045
16046                         DrawBox, ColBox, SelBox NodeBox
16047
16048                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16049
16050                         LegacyFaceDir bool
16051                         LegacyMounted bool
16052
16053                         DigPredict string
16054
16055                         MaxLvl uint8
16056
16057                         AlphaUse
16058
16059                         MoveResistance uint8
16060
16061                         LiquidMovePhysics bool
16062                 }))(obj)).ConnectTo)) > math.MaxUint16 {
16063                         chk(ErrTooLong)
16064                 }
16065                 {
16066                         x := uint16(len(((*(*(struct {
16067                                 Param0 Content
16068
16069                                 Name   string
16070                                 Groups []Group
16071
16072                                 P1Type   Param1Type
16073                                 P2Type   Param2Type
16074                                 DrawType DrawType
16075
16076                                 Mesh  string
16077                                 Scale float32
16078                                 //mt:const uint8(6)
16079                                 Tiles        [6]TileDef
16080                                 OverlayTiles [6]TileDef
16081                                 //mt:const uint8(6)
16082                                 SpecialTiles [6]TileDef
16083
16084                                 Color   color.NRGBA
16085                                 Palette Texture
16086
16087                                 Waving       WaveType
16088                                 ConnectSides uint8
16089                                 ConnectTo    []Content
16090                                 InsideTint   color.NRGBA
16091                                 Level        uint8 // Must be < 128.
16092
16093                                 Translucent bool // Sunlight is scattered and becomes normal light.
16094                                 Transparent bool // Sunlight isn't scattered.
16095                                 LightSrc    uint8
16096
16097                                 GndContent   bool
16098                                 Collides     bool
16099                                 Pointable    bool
16100                                 Diggable     bool
16101                                 Climbable    bool
16102                                 Replaceable  bool
16103                                 OnRightClick bool
16104
16105                                 DmgPerSec int32
16106
16107                                 LiquidType   LiquidType
16108                                 FlowingAlt   string
16109                                 SrcAlt       string
16110                                 Viscosity    uint8 // 0-7
16111                                 LiqRenewable bool
16112                                 FlowRange    uint8
16113                                 DrownDmg     uint8
16114                                 Floodable    bool
16115
16116                                 DrawBox, ColBox, SelBox NodeBox
16117
16118                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16119
16120                                 LegacyFaceDir bool
16121                                 LegacyMounted bool
16122
16123                                 DigPredict string
16124
16125                                 MaxLvl uint8
16126
16127                                 AlphaUse
16128
16129                                 MoveResistance uint8
16130
16131                                 LiquidMovePhysics bool
16132                         }))(obj)).ConnectTo)))
16133                         write16(w, uint16(x))
16134                 }
16135                 for local245 := range (*(*(struct {
16136                         Param0 Content
16137
16138                         Name   string
16139                         Groups []Group
16140
16141                         P1Type   Param1Type
16142                         P2Type   Param2Type
16143                         DrawType DrawType
16144
16145                         Mesh  string
16146                         Scale float32
16147                         //mt:const uint8(6)
16148                         Tiles        [6]TileDef
16149                         OverlayTiles [6]TileDef
16150                         //mt:const uint8(6)
16151                         SpecialTiles [6]TileDef
16152
16153                         Color   color.NRGBA
16154                         Palette Texture
16155
16156                         Waving       WaveType
16157                         ConnectSides uint8
16158                         ConnectTo    []Content
16159                         InsideTint   color.NRGBA
16160                         Level        uint8 // Must be < 128.
16161
16162                         Translucent bool // Sunlight is scattered and becomes normal light.
16163                         Transparent bool // Sunlight isn't scattered.
16164                         LightSrc    uint8
16165
16166                         GndContent   bool
16167                         Collides     bool
16168                         Pointable    bool
16169                         Diggable     bool
16170                         Climbable    bool
16171                         Replaceable  bool
16172                         OnRightClick bool
16173
16174                         DmgPerSec int32
16175
16176                         LiquidType   LiquidType
16177                         FlowingAlt   string
16178                         SrcAlt       string
16179                         Viscosity    uint8 // 0-7
16180                         LiqRenewable bool
16181                         FlowRange    uint8
16182                         DrownDmg     uint8
16183                         Floodable    bool
16184
16185                         DrawBox, ColBox, SelBox NodeBox
16186
16187                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16188
16189                         LegacyFaceDir bool
16190                         LegacyMounted bool
16191
16192                         DigPredict string
16193
16194                         MaxLvl uint8
16195
16196                         AlphaUse
16197
16198                         MoveResistance uint8
16199
16200                         LiquidMovePhysics bool
16201                 }))(obj)).ConnectTo {
16202                         if err := pcall(func() {
16203                                 (((*(*(struct {
16204                                         Param0 Content
16205
16206                                         Name   string
16207                                         Groups []Group
16208
16209                                         P1Type   Param1Type
16210                                         P2Type   Param2Type
16211                                         DrawType DrawType
16212
16213                                         Mesh  string
16214                                         Scale float32
16215                                         //mt:const uint8(6)
16216                                         Tiles        [6]TileDef
16217                                         OverlayTiles [6]TileDef
16218                                         //mt:const uint8(6)
16219                                         SpecialTiles [6]TileDef
16220
16221                                         Color   color.NRGBA
16222                                         Palette Texture
16223
16224                                         Waving       WaveType
16225                                         ConnectSides uint8
16226                                         ConnectTo    []Content
16227                                         InsideTint   color.NRGBA
16228                                         Level        uint8 // Must be < 128.
16229
16230                                         Translucent bool // Sunlight is scattered and becomes normal light.
16231                                         Transparent bool // Sunlight isn't scattered.
16232                                         LightSrc    uint8
16233
16234                                         GndContent   bool
16235                                         Collides     bool
16236                                         Pointable    bool
16237                                         Diggable     bool
16238                                         Climbable    bool
16239                                         Replaceable  bool
16240                                         OnRightClick bool
16241
16242                                         DmgPerSec int32
16243
16244                                         LiquidType   LiquidType
16245                                         FlowingAlt   string
16246                                         SrcAlt       string
16247                                         Viscosity    uint8 // 0-7
16248                                         LiqRenewable bool
16249                                         FlowRange    uint8
16250                                         DrownDmg     uint8
16251                                         Floodable    bool
16252
16253                                         DrawBox, ColBox, SelBox NodeBox
16254
16255                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16256
16257                                         LegacyFaceDir bool
16258                                         LegacyMounted bool
16259
16260                                         DigPredict string
16261
16262                                         MaxLvl uint8
16263
16264                                         AlphaUse
16265
16266                                         MoveResistance uint8
16267
16268                                         LiquidMovePhysics bool
16269                                 }))(obj)).ConnectTo)[local245]).serialize(w)
16270                         }); err != nil {
16271                                 if err == io.EOF {
16272                                         chk(io.EOF)
16273                                 }
16274                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
16275                         }
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
16341                                 MoveResistance uint8
16342
16343                                 LiquidMovePhysics bool
16344                         }))(obj)).InsideTint
16345                         w.Write([]byte{x.A, x.R, x.G, x.B})
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
16411                                 MoveResistance uint8
16412
16413                                 LiquidMovePhysics bool
16414                         }))(obj)).Level
16415                         write8(w, uint8(x))
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
16481                                 MoveResistance uint8
16482
16483                                 LiquidMovePhysics bool
16484                         }))(obj)).Translucent
16485                         if x {
16486                                 write8(w, 1)
16487                         } else {
16488                                 write8(w, 0)
16489                         }
16490                 }
16491                 {
16492                         x := (*(*(struct {
16493                                 Param0 Content
16494
16495                                 Name   string
16496                                 Groups []Group
16497
16498                                 P1Type   Param1Type
16499                                 P2Type   Param2Type
16500                                 DrawType DrawType
16501
16502                                 Mesh  string
16503                                 Scale float32
16504                                 //mt:const uint8(6)
16505                                 Tiles        [6]TileDef
16506                                 OverlayTiles [6]TileDef
16507                                 //mt:const uint8(6)
16508                                 SpecialTiles [6]TileDef
16509
16510                                 Color   color.NRGBA
16511                                 Palette Texture
16512
16513                                 Waving       WaveType
16514                                 ConnectSides uint8
16515                                 ConnectTo    []Content
16516                                 InsideTint   color.NRGBA
16517                                 Level        uint8 // Must be < 128.
16518
16519                                 Translucent bool // Sunlight is scattered and becomes normal light.
16520                                 Transparent bool // Sunlight isn't scattered.
16521                                 LightSrc    uint8
16522
16523                                 GndContent   bool
16524                                 Collides     bool
16525                                 Pointable    bool
16526                                 Diggable     bool
16527                                 Climbable    bool
16528                                 Replaceable  bool
16529                                 OnRightClick bool
16530
16531                                 DmgPerSec int32
16532
16533                                 LiquidType   LiquidType
16534                                 FlowingAlt   string
16535                                 SrcAlt       string
16536                                 Viscosity    uint8 // 0-7
16537                                 LiqRenewable bool
16538                                 FlowRange    uint8
16539                                 DrownDmg     uint8
16540                                 Floodable    bool
16541
16542                                 DrawBox, ColBox, SelBox NodeBox
16543
16544                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16545
16546                                 LegacyFaceDir bool
16547                                 LegacyMounted bool
16548
16549                                 DigPredict string
16550
16551                                 MaxLvl uint8
16552
16553                                 AlphaUse
16554
16555                                 MoveResistance uint8
16556
16557                                 LiquidMovePhysics bool
16558                         }))(obj)).Transparent
16559                         if x {
16560                                 write8(w, 1)
16561                         } else {
16562                                 write8(w, 0)
16563                         }
16564                 }
16565                 {
16566                         x := (*(*(struct {
16567                                 Param0 Content
16568
16569                                 Name   string
16570                                 Groups []Group
16571
16572                                 P1Type   Param1Type
16573                                 P2Type   Param2Type
16574                                 DrawType DrawType
16575
16576                                 Mesh  string
16577                                 Scale float32
16578                                 //mt:const uint8(6)
16579                                 Tiles        [6]TileDef
16580                                 OverlayTiles [6]TileDef
16581                                 //mt:const uint8(6)
16582                                 SpecialTiles [6]TileDef
16583
16584                                 Color   color.NRGBA
16585                                 Palette Texture
16586
16587                                 Waving       WaveType
16588                                 ConnectSides uint8
16589                                 ConnectTo    []Content
16590                                 InsideTint   color.NRGBA
16591                                 Level        uint8 // Must be < 128.
16592
16593                                 Translucent bool // Sunlight is scattered and becomes normal light.
16594                                 Transparent bool // Sunlight isn't scattered.
16595                                 LightSrc    uint8
16596
16597                                 GndContent   bool
16598                                 Collides     bool
16599                                 Pointable    bool
16600                                 Diggable     bool
16601                                 Climbable    bool
16602                                 Replaceable  bool
16603                                 OnRightClick bool
16604
16605                                 DmgPerSec int32
16606
16607                                 LiquidType   LiquidType
16608                                 FlowingAlt   string
16609                                 SrcAlt       string
16610                                 Viscosity    uint8 // 0-7
16611                                 LiqRenewable bool
16612                                 FlowRange    uint8
16613                                 DrownDmg     uint8
16614                                 Floodable    bool
16615
16616                                 DrawBox, ColBox, SelBox NodeBox
16617
16618                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16619
16620                                 LegacyFaceDir bool
16621                                 LegacyMounted bool
16622
16623                                 DigPredict string
16624
16625                                 MaxLvl uint8
16626
16627                                 AlphaUse
16628
16629                                 MoveResistance uint8
16630
16631                                 LiquidMovePhysics bool
16632                         }))(obj)).LightSrc
16633                         write8(w, uint8(x))
16634                 }
16635                 {
16636                         x := (*(*(struct {
16637                                 Param0 Content
16638
16639                                 Name   string
16640                                 Groups []Group
16641
16642                                 P1Type   Param1Type
16643                                 P2Type   Param2Type
16644                                 DrawType DrawType
16645
16646                                 Mesh  string
16647                                 Scale float32
16648                                 //mt:const uint8(6)
16649                                 Tiles        [6]TileDef
16650                                 OverlayTiles [6]TileDef
16651                                 //mt:const uint8(6)
16652                                 SpecialTiles [6]TileDef
16653
16654                                 Color   color.NRGBA
16655                                 Palette Texture
16656
16657                                 Waving       WaveType
16658                                 ConnectSides uint8
16659                                 ConnectTo    []Content
16660                                 InsideTint   color.NRGBA
16661                                 Level        uint8 // Must be < 128.
16662
16663                                 Translucent bool // Sunlight is scattered and becomes normal light.
16664                                 Transparent bool // Sunlight isn't scattered.
16665                                 LightSrc    uint8
16666
16667                                 GndContent   bool
16668                                 Collides     bool
16669                                 Pointable    bool
16670                                 Diggable     bool
16671                                 Climbable    bool
16672                                 Replaceable  bool
16673                                 OnRightClick bool
16674
16675                                 DmgPerSec int32
16676
16677                                 LiquidType   LiquidType
16678                                 FlowingAlt   string
16679                                 SrcAlt       string
16680                                 Viscosity    uint8 // 0-7
16681                                 LiqRenewable bool
16682                                 FlowRange    uint8
16683                                 DrownDmg     uint8
16684                                 Floodable    bool
16685
16686                                 DrawBox, ColBox, SelBox NodeBox
16687
16688                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16689
16690                                 LegacyFaceDir bool
16691                                 LegacyMounted bool
16692
16693                                 DigPredict string
16694
16695                                 MaxLvl uint8
16696
16697                                 AlphaUse
16698
16699                                 MoveResistance uint8
16700
16701                                 LiquidMovePhysics bool
16702                         }))(obj)).GndContent
16703                         if x {
16704                                 write8(w, 1)
16705                         } else {
16706                                 write8(w, 0)
16707                         }
16708                 }
16709                 {
16710                         x := (*(*(struct {
16711                                 Param0 Content
16712
16713                                 Name   string
16714                                 Groups []Group
16715
16716                                 P1Type   Param1Type
16717                                 P2Type   Param2Type
16718                                 DrawType DrawType
16719
16720                                 Mesh  string
16721                                 Scale float32
16722                                 //mt:const uint8(6)
16723                                 Tiles        [6]TileDef
16724                                 OverlayTiles [6]TileDef
16725                                 //mt:const uint8(6)
16726                                 SpecialTiles [6]TileDef
16727
16728                                 Color   color.NRGBA
16729                                 Palette Texture
16730
16731                                 Waving       WaveType
16732                                 ConnectSides uint8
16733                                 ConnectTo    []Content
16734                                 InsideTint   color.NRGBA
16735                                 Level        uint8 // Must be < 128.
16736
16737                                 Translucent bool // Sunlight is scattered and becomes normal light.
16738                                 Transparent bool // Sunlight isn't scattered.
16739                                 LightSrc    uint8
16740
16741                                 GndContent   bool
16742                                 Collides     bool
16743                                 Pointable    bool
16744                                 Diggable     bool
16745                                 Climbable    bool
16746                                 Replaceable  bool
16747                                 OnRightClick bool
16748
16749                                 DmgPerSec int32
16750
16751                                 LiquidType   LiquidType
16752                                 FlowingAlt   string
16753                                 SrcAlt       string
16754                                 Viscosity    uint8 // 0-7
16755                                 LiqRenewable bool
16756                                 FlowRange    uint8
16757                                 DrownDmg     uint8
16758                                 Floodable    bool
16759
16760                                 DrawBox, ColBox, SelBox NodeBox
16761
16762                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16763
16764                                 LegacyFaceDir bool
16765                                 LegacyMounted bool
16766
16767                                 DigPredict string
16768
16769                                 MaxLvl uint8
16770
16771                                 AlphaUse
16772
16773                                 MoveResistance uint8
16774
16775                                 LiquidMovePhysics bool
16776                         }))(obj)).Collides
16777                         if x {
16778                                 write8(w, 1)
16779                         } else {
16780                                 write8(w, 0)
16781                         }
16782                 }
16783                 {
16784                         x := (*(*(struct {
16785                                 Param0 Content
16786
16787                                 Name   string
16788                                 Groups []Group
16789
16790                                 P1Type   Param1Type
16791                                 P2Type   Param2Type
16792                                 DrawType DrawType
16793
16794                                 Mesh  string
16795                                 Scale float32
16796                                 //mt:const uint8(6)
16797                                 Tiles        [6]TileDef
16798                                 OverlayTiles [6]TileDef
16799                                 //mt:const uint8(6)
16800                                 SpecialTiles [6]TileDef
16801
16802                                 Color   color.NRGBA
16803                                 Palette Texture
16804
16805                                 Waving       WaveType
16806                                 ConnectSides uint8
16807                                 ConnectTo    []Content
16808                                 InsideTint   color.NRGBA
16809                                 Level        uint8 // Must be < 128.
16810
16811                                 Translucent bool // Sunlight is scattered and becomes normal light.
16812                                 Transparent bool // Sunlight isn't scattered.
16813                                 LightSrc    uint8
16814
16815                                 GndContent   bool
16816                                 Collides     bool
16817                                 Pointable    bool
16818                                 Diggable     bool
16819                                 Climbable    bool
16820                                 Replaceable  bool
16821                                 OnRightClick bool
16822
16823                                 DmgPerSec int32
16824
16825                                 LiquidType   LiquidType
16826                                 FlowingAlt   string
16827                                 SrcAlt       string
16828                                 Viscosity    uint8 // 0-7
16829                                 LiqRenewable bool
16830                                 FlowRange    uint8
16831                                 DrownDmg     uint8
16832                                 Floodable    bool
16833
16834                                 DrawBox, ColBox, SelBox NodeBox
16835
16836                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16837
16838                                 LegacyFaceDir bool
16839                                 LegacyMounted bool
16840
16841                                 DigPredict string
16842
16843                                 MaxLvl uint8
16844
16845                                 AlphaUse
16846
16847                                 MoveResistance uint8
16848
16849                                 LiquidMovePhysics bool
16850                         }))(obj)).Pointable
16851                         if x {
16852                                 write8(w, 1)
16853                         } else {
16854                                 write8(w, 0)
16855                         }
16856                 }
16857                 {
16858                         x := (*(*(struct {
16859                                 Param0 Content
16860
16861                                 Name   string
16862                                 Groups []Group
16863
16864                                 P1Type   Param1Type
16865                                 P2Type   Param2Type
16866                                 DrawType DrawType
16867
16868                                 Mesh  string
16869                                 Scale float32
16870                                 //mt:const uint8(6)
16871                                 Tiles        [6]TileDef
16872                                 OverlayTiles [6]TileDef
16873                                 //mt:const uint8(6)
16874                                 SpecialTiles [6]TileDef
16875
16876                                 Color   color.NRGBA
16877                                 Palette Texture
16878
16879                                 Waving       WaveType
16880                                 ConnectSides uint8
16881                                 ConnectTo    []Content
16882                                 InsideTint   color.NRGBA
16883                                 Level        uint8 // Must be < 128.
16884
16885                                 Translucent bool // Sunlight is scattered and becomes normal light.
16886                                 Transparent bool // Sunlight isn't scattered.
16887                                 LightSrc    uint8
16888
16889                                 GndContent   bool
16890                                 Collides     bool
16891                                 Pointable    bool
16892                                 Diggable     bool
16893                                 Climbable    bool
16894                                 Replaceable  bool
16895                                 OnRightClick bool
16896
16897                                 DmgPerSec int32
16898
16899                                 LiquidType   LiquidType
16900                                 FlowingAlt   string
16901                                 SrcAlt       string
16902                                 Viscosity    uint8 // 0-7
16903                                 LiqRenewable bool
16904                                 FlowRange    uint8
16905                                 DrownDmg     uint8
16906                                 Floodable    bool
16907
16908                                 DrawBox, ColBox, SelBox NodeBox
16909
16910                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16911
16912                                 LegacyFaceDir bool
16913                                 LegacyMounted bool
16914
16915                                 DigPredict string
16916
16917                                 MaxLvl uint8
16918
16919                                 AlphaUse
16920
16921                                 MoveResistance uint8
16922
16923                                 LiquidMovePhysics bool
16924                         }))(obj)).Diggable
16925                         if x {
16926                                 write8(w, 1)
16927                         } else {
16928                                 write8(w, 0)
16929                         }
16930                 }
16931                 {
16932                         x := (*(*(struct {
16933                                 Param0 Content
16934
16935                                 Name   string
16936                                 Groups []Group
16937
16938                                 P1Type   Param1Type
16939                                 P2Type   Param2Type
16940                                 DrawType DrawType
16941
16942                                 Mesh  string
16943                                 Scale float32
16944                                 //mt:const uint8(6)
16945                                 Tiles        [6]TileDef
16946                                 OverlayTiles [6]TileDef
16947                                 //mt:const uint8(6)
16948                                 SpecialTiles [6]TileDef
16949
16950                                 Color   color.NRGBA
16951                                 Palette Texture
16952
16953                                 Waving       WaveType
16954                                 ConnectSides uint8
16955                                 ConnectTo    []Content
16956                                 InsideTint   color.NRGBA
16957                                 Level        uint8 // Must be < 128.
16958
16959                                 Translucent bool // Sunlight is scattered and becomes normal light.
16960                                 Transparent bool // Sunlight isn't scattered.
16961                                 LightSrc    uint8
16962
16963                                 GndContent   bool
16964                                 Collides     bool
16965                                 Pointable    bool
16966                                 Diggable     bool
16967                                 Climbable    bool
16968                                 Replaceable  bool
16969                                 OnRightClick bool
16970
16971                                 DmgPerSec int32
16972
16973                                 LiquidType   LiquidType
16974                                 FlowingAlt   string
16975                                 SrcAlt       string
16976                                 Viscosity    uint8 // 0-7
16977                                 LiqRenewable bool
16978                                 FlowRange    uint8
16979                                 DrownDmg     uint8
16980                                 Floodable    bool
16981
16982                                 DrawBox, ColBox, SelBox NodeBox
16983
16984                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16985
16986                                 LegacyFaceDir bool
16987                                 LegacyMounted bool
16988
16989                                 DigPredict string
16990
16991                                 MaxLvl uint8
16992
16993                                 AlphaUse
16994
16995                                 MoveResistance uint8
16996
16997                                 LiquidMovePhysics bool
16998                         }))(obj)).Climbable
16999                         if x {
17000                                 write8(w, 1)
17001                         } else {
17002                                 write8(w, 0)
17003                         }
17004                 }
17005                 {
17006                         x := (*(*(struct {
17007                                 Param0 Content
17008
17009                                 Name   string
17010                                 Groups []Group
17011
17012                                 P1Type   Param1Type
17013                                 P2Type   Param2Type
17014                                 DrawType DrawType
17015
17016                                 Mesh  string
17017                                 Scale float32
17018                                 //mt:const uint8(6)
17019                                 Tiles        [6]TileDef
17020                                 OverlayTiles [6]TileDef
17021                                 //mt:const uint8(6)
17022                                 SpecialTiles [6]TileDef
17023
17024                                 Color   color.NRGBA
17025                                 Palette Texture
17026
17027                                 Waving       WaveType
17028                                 ConnectSides uint8
17029                                 ConnectTo    []Content
17030                                 InsideTint   color.NRGBA
17031                                 Level        uint8 // Must be < 128.
17032
17033                                 Translucent bool // Sunlight is scattered and becomes normal light.
17034                                 Transparent bool // Sunlight isn't scattered.
17035                                 LightSrc    uint8
17036
17037                                 GndContent   bool
17038                                 Collides     bool
17039                                 Pointable    bool
17040                                 Diggable     bool
17041                                 Climbable    bool
17042                                 Replaceable  bool
17043                                 OnRightClick bool
17044
17045                                 DmgPerSec int32
17046
17047                                 LiquidType   LiquidType
17048                                 FlowingAlt   string
17049                                 SrcAlt       string
17050                                 Viscosity    uint8 // 0-7
17051                                 LiqRenewable bool
17052                                 FlowRange    uint8
17053                                 DrownDmg     uint8
17054                                 Floodable    bool
17055
17056                                 DrawBox, ColBox, SelBox NodeBox
17057
17058                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17059
17060                                 LegacyFaceDir bool
17061                                 LegacyMounted bool
17062
17063                                 DigPredict string
17064
17065                                 MaxLvl uint8
17066
17067                                 AlphaUse
17068
17069                                 MoveResistance uint8
17070
17071                                 LiquidMovePhysics bool
17072                         }))(obj)).Replaceable
17073                         if x {
17074                                 write8(w, 1)
17075                         } else {
17076                                 write8(w, 0)
17077                         }
17078                 }
17079                 {
17080                         x := (*(*(struct {
17081                                 Param0 Content
17082
17083                                 Name   string
17084                                 Groups []Group
17085
17086                                 P1Type   Param1Type
17087                                 P2Type   Param2Type
17088                                 DrawType DrawType
17089
17090                                 Mesh  string
17091                                 Scale float32
17092                                 //mt:const uint8(6)
17093                                 Tiles        [6]TileDef
17094                                 OverlayTiles [6]TileDef
17095                                 //mt:const uint8(6)
17096                                 SpecialTiles [6]TileDef
17097
17098                                 Color   color.NRGBA
17099                                 Palette Texture
17100
17101                                 Waving       WaveType
17102                                 ConnectSides uint8
17103                                 ConnectTo    []Content
17104                                 InsideTint   color.NRGBA
17105                                 Level        uint8 // Must be < 128.
17106
17107                                 Translucent bool // Sunlight is scattered and becomes normal light.
17108                                 Transparent bool // Sunlight isn't scattered.
17109                                 LightSrc    uint8
17110
17111                                 GndContent   bool
17112                                 Collides     bool
17113                                 Pointable    bool
17114                                 Diggable     bool
17115                                 Climbable    bool
17116                                 Replaceable  bool
17117                                 OnRightClick bool
17118
17119                                 DmgPerSec int32
17120
17121                                 LiquidType   LiquidType
17122                                 FlowingAlt   string
17123                                 SrcAlt       string
17124                                 Viscosity    uint8 // 0-7
17125                                 LiqRenewable bool
17126                                 FlowRange    uint8
17127                                 DrownDmg     uint8
17128                                 Floodable    bool
17129
17130                                 DrawBox, ColBox, SelBox NodeBox
17131
17132                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17133
17134                                 LegacyFaceDir bool
17135                                 LegacyMounted bool
17136
17137                                 DigPredict string
17138
17139                                 MaxLvl uint8
17140
17141                                 AlphaUse
17142
17143                                 MoveResistance uint8
17144
17145                                 LiquidMovePhysics bool
17146                         }))(obj)).OnRightClick
17147                         if x {
17148                                 write8(w, 1)
17149                         } else {
17150                                 write8(w, 0)
17151                         }
17152                 }
17153                 {
17154                         x := (*(*(struct {
17155                                 Param0 Content
17156
17157                                 Name   string
17158                                 Groups []Group
17159
17160                                 P1Type   Param1Type
17161                                 P2Type   Param2Type
17162                                 DrawType DrawType
17163
17164                                 Mesh  string
17165                                 Scale float32
17166                                 //mt:const uint8(6)
17167                                 Tiles        [6]TileDef
17168                                 OverlayTiles [6]TileDef
17169                                 //mt:const uint8(6)
17170                                 SpecialTiles [6]TileDef
17171
17172                                 Color   color.NRGBA
17173                                 Palette Texture
17174
17175                                 Waving       WaveType
17176                                 ConnectSides uint8
17177                                 ConnectTo    []Content
17178                                 InsideTint   color.NRGBA
17179                                 Level        uint8 // Must be < 128.
17180
17181                                 Translucent bool // Sunlight is scattered and becomes normal light.
17182                                 Transparent bool // Sunlight isn't scattered.
17183                                 LightSrc    uint8
17184
17185                                 GndContent   bool
17186                                 Collides     bool
17187                                 Pointable    bool
17188                                 Diggable     bool
17189                                 Climbable    bool
17190                                 Replaceable  bool
17191                                 OnRightClick bool
17192
17193                                 DmgPerSec int32
17194
17195                                 LiquidType   LiquidType
17196                                 FlowingAlt   string
17197                                 SrcAlt       string
17198                                 Viscosity    uint8 // 0-7
17199                                 LiqRenewable bool
17200                                 FlowRange    uint8
17201                                 DrownDmg     uint8
17202                                 Floodable    bool
17203
17204                                 DrawBox, ColBox, SelBox NodeBox
17205
17206                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17207
17208                                 LegacyFaceDir bool
17209                                 LegacyMounted bool
17210
17211                                 DigPredict string
17212
17213                                 MaxLvl uint8
17214
17215                                 AlphaUse
17216
17217                                 MoveResistance uint8
17218
17219                                 LiquidMovePhysics bool
17220                         }))(obj)).DmgPerSec
17221                         write32(w, uint32(x))
17222                 }
17223                 if err := pcall(func() {
17224                         ((*(*(struct {
17225                                 Param0 Content
17226
17227                                 Name   string
17228                                 Groups []Group
17229
17230                                 P1Type   Param1Type
17231                                 P2Type   Param2Type
17232                                 DrawType DrawType
17233
17234                                 Mesh  string
17235                                 Scale float32
17236                                 //mt:const uint8(6)
17237                                 Tiles        [6]TileDef
17238                                 OverlayTiles [6]TileDef
17239                                 //mt:const uint8(6)
17240                                 SpecialTiles [6]TileDef
17241
17242                                 Color   color.NRGBA
17243                                 Palette Texture
17244
17245                                 Waving       WaveType
17246                                 ConnectSides uint8
17247                                 ConnectTo    []Content
17248                                 InsideTint   color.NRGBA
17249                                 Level        uint8 // Must be < 128.
17250
17251                                 Translucent bool // Sunlight is scattered and becomes normal light.
17252                                 Transparent bool // Sunlight isn't scattered.
17253                                 LightSrc    uint8
17254
17255                                 GndContent   bool
17256                                 Collides     bool
17257                                 Pointable    bool
17258                                 Diggable     bool
17259                                 Climbable    bool
17260                                 Replaceable  bool
17261                                 OnRightClick bool
17262
17263                                 DmgPerSec int32
17264
17265                                 LiquidType   LiquidType
17266                                 FlowingAlt   string
17267                                 SrcAlt       string
17268                                 Viscosity    uint8 // 0-7
17269                                 LiqRenewable bool
17270                                 FlowRange    uint8
17271                                 DrownDmg     uint8
17272                                 Floodable    bool
17273
17274                                 DrawBox, ColBox, SelBox NodeBox
17275
17276                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17277
17278                                 LegacyFaceDir bool
17279                                 LegacyMounted bool
17280
17281                                 DigPredict string
17282
17283                                 MaxLvl uint8
17284
17285                                 AlphaUse
17286
17287                                 MoveResistance uint8
17288
17289                                 LiquidMovePhysics bool
17290                         }))(obj)).LiquidType).serialize(w)
17291                 }); err != nil {
17292                         if err == io.EOF {
17293                                 chk(io.EOF)
17294                         }
17295                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LiquidType", err))
17296                 }
17297                 if len(([]byte((*(*(struct {
17298                         Param0 Content
17299
17300                         Name   string
17301                         Groups []Group
17302
17303                         P1Type   Param1Type
17304                         P2Type   Param2Type
17305                         DrawType DrawType
17306
17307                         Mesh  string
17308                         Scale float32
17309                         //mt:const uint8(6)
17310                         Tiles        [6]TileDef
17311                         OverlayTiles [6]TileDef
17312                         //mt:const uint8(6)
17313                         SpecialTiles [6]TileDef
17314
17315                         Color   color.NRGBA
17316                         Palette Texture
17317
17318                         Waving       WaveType
17319                         ConnectSides uint8
17320                         ConnectTo    []Content
17321                         InsideTint   color.NRGBA
17322                         Level        uint8 // Must be < 128.
17323
17324                         Translucent bool // Sunlight is scattered and becomes normal light.
17325                         Transparent bool // Sunlight isn't scattered.
17326                         LightSrc    uint8
17327
17328                         GndContent   bool
17329                         Collides     bool
17330                         Pointable    bool
17331                         Diggable     bool
17332                         Climbable    bool
17333                         Replaceable  bool
17334                         OnRightClick bool
17335
17336                         DmgPerSec int32
17337
17338                         LiquidType   LiquidType
17339                         FlowingAlt   string
17340                         SrcAlt       string
17341                         Viscosity    uint8 // 0-7
17342                         LiqRenewable bool
17343                         FlowRange    uint8
17344                         DrownDmg     uint8
17345                         Floodable    bool
17346
17347                         DrawBox, ColBox, SelBox NodeBox
17348
17349                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17350
17351                         LegacyFaceDir bool
17352                         LegacyMounted bool
17353
17354                         DigPredict string
17355
17356                         MaxLvl uint8
17357
17358                         AlphaUse
17359
17360                         MoveResistance uint8
17361
17362                         LiquidMovePhysics bool
17363                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
17364                         chk(ErrTooLong)
17365                 }
17366                 {
17367                         x := uint16(len(([]byte((*(*(struct {
17368                                 Param0 Content
17369
17370                                 Name   string
17371                                 Groups []Group
17372
17373                                 P1Type   Param1Type
17374                                 P2Type   Param2Type
17375                                 DrawType DrawType
17376
17377                                 Mesh  string
17378                                 Scale float32
17379                                 //mt:const uint8(6)
17380                                 Tiles        [6]TileDef
17381                                 OverlayTiles [6]TileDef
17382                                 //mt:const uint8(6)
17383                                 SpecialTiles [6]TileDef
17384
17385                                 Color   color.NRGBA
17386                                 Palette Texture
17387
17388                                 Waving       WaveType
17389                                 ConnectSides uint8
17390                                 ConnectTo    []Content
17391                                 InsideTint   color.NRGBA
17392                                 Level        uint8 // Must be < 128.
17393
17394                                 Translucent bool // Sunlight is scattered and becomes normal light.
17395                                 Transparent bool // Sunlight isn't scattered.
17396                                 LightSrc    uint8
17397
17398                                 GndContent   bool
17399                                 Collides     bool
17400                                 Pointable    bool
17401                                 Diggable     bool
17402                                 Climbable    bool
17403                                 Replaceable  bool
17404                                 OnRightClick bool
17405
17406                                 DmgPerSec int32
17407
17408                                 LiquidType   LiquidType
17409                                 FlowingAlt   string
17410                                 SrcAlt       string
17411                                 Viscosity    uint8 // 0-7
17412                                 LiqRenewable bool
17413                                 FlowRange    uint8
17414                                 DrownDmg     uint8
17415                                 Floodable    bool
17416
17417                                 DrawBox, ColBox, SelBox NodeBox
17418
17419                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17420
17421                                 LegacyFaceDir bool
17422                                 LegacyMounted bool
17423
17424                                 DigPredict string
17425
17426                                 MaxLvl uint8
17427
17428                                 AlphaUse
17429
17430                                 MoveResistance uint8
17431
17432                                 LiquidMovePhysics bool
17433                         }))(obj)).FlowingAlt))))
17434                         write16(w, uint16(x))
17435                 }
17436                 {
17437                         _, err := w.Write(([]byte((*(*(struct {
17438                                 Param0 Content
17439
17440                                 Name   string
17441                                 Groups []Group
17442
17443                                 P1Type   Param1Type
17444                                 P2Type   Param2Type
17445                                 DrawType DrawType
17446
17447                                 Mesh  string
17448                                 Scale float32
17449                                 //mt:const uint8(6)
17450                                 Tiles        [6]TileDef
17451                                 OverlayTiles [6]TileDef
17452                                 //mt:const uint8(6)
17453                                 SpecialTiles [6]TileDef
17454
17455                                 Color   color.NRGBA
17456                                 Palette Texture
17457
17458                                 Waving       WaveType
17459                                 ConnectSides uint8
17460                                 ConnectTo    []Content
17461                                 InsideTint   color.NRGBA
17462                                 Level        uint8 // Must be < 128.
17463
17464                                 Translucent bool // Sunlight is scattered and becomes normal light.
17465                                 Transparent bool // Sunlight isn't scattered.
17466                                 LightSrc    uint8
17467
17468                                 GndContent   bool
17469                                 Collides     bool
17470                                 Pointable    bool
17471                                 Diggable     bool
17472                                 Climbable    bool
17473                                 Replaceable  bool
17474                                 OnRightClick bool
17475
17476                                 DmgPerSec int32
17477
17478                                 LiquidType   LiquidType
17479                                 FlowingAlt   string
17480                                 SrcAlt       string
17481                                 Viscosity    uint8 // 0-7
17482                                 LiqRenewable bool
17483                                 FlowRange    uint8
17484                                 DrownDmg     uint8
17485                                 Floodable    bool
17486
17487                                 DrawBox, ColBox, SelBox NodeBox
17488
17489                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17490
17491                                 LegacyFaceDir bool
17492                                 LegacyMounted bool
17493
17494                                 DigPredict string
17495
17496                                 MaxLvl uint8
17497
17498                                 AlphaUse
17499
17500                                 MoveResistance uint8
17501
17502                                 LiquidMovePhysics bool
17503                         }))(obj)).FlowingAlt))[:])
17504                         chk(err)
17505                 }
17506                 if len(([]byte((*(*(struct {
17507                         Param0 Content
17508
17509                         Name   string
17510                         Groups []Group
17511
17512                         P1Type   Param1Type
17513                         P2Type   Param2Type
17514                         DrawType DrawType
17515
17516                         Mesh  string
17517                         Scale float32
17518                         //mt:const uint8(6)
17519                         Tiles        [6]TileDef
17520                         OverlayTiles [6]TileDef
17521                         //mt:const uint8(6)
17522                         SpecialTiles [6]TileDef
17523
17524                         Color   color.NRGBA
17525                         Palette Texture
17526
17527                         Waving       WaveType
17528                         ConnectSides uint8
17529                         ConnectTo    []Content
17530                         InsideTint   color.NRGBA
17531                         Level        uint8 // Must be < 128.
17532
17533                         Translucent bool // Sunlight is scattered and becomes normal light.
17534                         Transparent bool // Sunlight isn't scattered.
17535                         LightSrc    uint8
17536
17537                         GndContent   bool
17538                         Collides     bool
17539                         Pointable    bool
17540                         Diggable     bool
17541                         Climbable    bool
17542                         Replaceable  bool
17543                         OnRightClick bool
17544
17545                         DmgPerSec int32
17546
17547                         LiquidType   LiquidType
17548                         FlowingAlt   string
17549                         SrcAlt       string
17550                         Viscosity    uint8 // 0-7
17551                         LiqRenewable bool
17552                         FlowRange    uint8
17553                         DrownDmg     uint8
17554                         Floodable    bool
17555
17556                         DrawBox, ColBox, SelBox NodeBox
17557
17558                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17559
17560                         LegacyFaceDir bool
17561                         LegacyMounted bool
17562
17563                         DigPredict string
17564
17565                         MaxLvl uint8
17566
17567                         AlphaUse
17568
17569                         MoveResistance uint8
17570
17571                         LiquidMovePhysics bool
17572                 }))(obj)).SrcAlt))) > math.MaxUint16 {
17573                         chk(ErrTooLong)
17574                 }
17575                 {
17576                         x := uint16(len(([]byte((*(*(struct {
17577                                 Param0 Content
17578
17579                                 Name   string
17580                                 Groups []Group
17581
17582                                 P1Type   Param1Type
17583                                 P2Type   Param2Type
17584                                 DrawType DrawType
17585
17586                                 Mesh  string
17587                                 Scale float32
17588                                 //mt:const uint8(6)
17589                                 Tiles        [6]TileDef
17590                                 OverlayTiles [6]TileDef
17591                                 //mt:const uint8(6)
17592                                 SpecialTiles [6]TileDef
17593
17594                                 Color   color.NRGBA
17595                                 Palette Texture
17596
17597                                 Waving       WaveType
17598                                 ConnectSides uint8
17599                                 ConnectTo    []Content
17600                                 InsideTint   color.NRGBA
17601                                 Level        uint8 // Must be < 128.
17602
17603                                 Translucent bool // Sunlight is scattered and becomes normal light.
17604                                 Transparent bool // Sunlight isn't scattered.
17605                                 LightSrc    uint8
17606
17607                                 GndContent   bool
17608                                 Collides     bool
17609                                 Pointable    bool
17610                                 Diggable     bool
17611                                 Climbable    bool
17612                                 Replaceable  bool
17613                                 OnRightClick bool
17614
17615                                 DmgPerSec int32
17616
17617                                 LiquidType   LiquidType
17618                                 FlowingAlt   string
17619                                 SrcAlt       string
17620                                 Viscosity    uint8 // 0-7
17621                                 LiqRenewable bool
17622                                 FlowRange    uint8
17623                                 DrownDmg     uint8
17624                                 Floodable    bool
17625
17626                                 DrawBox, ColBox, SelBox NodeBox
17627
17628                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17629
17630                                 LegacyFaceDir bool
17631                                 LegacyMounted bool
17632
17633                                 DigPredict string
17634
17635                                 MaxLvl uint8
17636
17637                                 AlphaUse
17638
17639                                 MoveResistance uint8
17640
17641                                 LiquidMovePhysics bool
17642                         }))(obj)).SrcAlt))))
17643                         write16(w, uint16(x))
17644                 }
17645                 {
17646                         _, err := w.Write(([]byte((*(*(struct {
17647                                 Param0 Content
17648
17649                                 Name   string
17650                                 Groups []Group
17651
17652                                 P1Type   Param1Type
17653                                 P2Type   Param2Type
17654                                 DrawType DrawType
17655
17656                                 Mesh  string
17657                                 Scale float32
17658                                 //mt:const uint8(6)
17659                                 Tiles        [6]TileDef
17660                                 OverlayTiles [6]TileDef
17661                                 //mt:const uint8(6)
17662                                 SpecialTiles [6]TileDef
17663
17664                                 Color   color.NRGBA
17665                                 Palette Texture
17666
17667                                 Waving       WaveType
17668                                 ConnectSides uint8
17669                                 ConnectTo    []Content
17670                                 InsideTint   color.NRGBA
17671                                 Level        uint8 // Must be < 128.
17672
17673                                 Translucent bool // Sunlight is scattered and becomes normal light.
17674                                 Transparent bool // Sunlight isn't scattered.
17675                                 LightSrc    uint8
17676
17677                                 GndContent   bool
17678                                 Collides     bool
17679                                 Pointable    bool
17680                                 Diggable     bool
17681                                 Climbable    bool
17682                                 Replaceable  bool
17683                                 OnRightClick bool
17684
17685                                 DmgPerSec int32
17686
17687                                 LiquidType   LiquidType
17688                                 FlowingAlt   string
17689                                 SrcAlt       string
17690                                 Viscosity    uint8 // 0-7
17691                                 LiqRenewable bool
17692                                 FlowRange    uint8
17693                                 DrownDmg     uint8
17694                                 Floodable    bool
17695
17696                                 DrawBox, ColBox, SelBox NodeBox
17697
17698                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17699
17700                                 LegacyFaceDir bool
17701                                 LegacyMounted bool
17702
17703                                 DigPredict string
17704
17705                                 MaxLvl uint8
17706
17707                                 AlphaUse
17708
17709                                 MoveResistance uint8
17710
17711                                 LiquidMovePhysics bool
17712                         }))(obj)).SrcAlt))[:])
17713                         chk(err)
17714                 }
17715                 {
17716                         x := (*(*(struct {
17717                                 Param0 Content
17718
17719                                 Name   string
17720                                 Groups []Group
17721
17722                                 P1Type   Param1Type
17723                                 P2Type   Param2Type
17724                                 DrawType DrawType
17725
17726                                 Mesh  string
17727                                 Scale float32
17728                                 //mt:const uint8(6)
17729                                 Tiles        [6]TileDef
17730                                 OverlayTiles [6]TileDef
17731                                 //mt:const uint8(6)
17732                                 SpecialTiles [6]TileDef
17733
17734                                 Color   color.NRGBA
17735                                 Palette Texture
17736
17737                                 Waving       WaveType
17738                                 ConnectSides uint8
17739                                 ConnectTo    []Content
17740                                 InsideTint   color.NRGBA
17741                                 Level        uint8 // Must be < 128.
17742
17743                                 Translucent bool // Sunlight is scattered and becomes normal light.
17744                                 Transparent bool // Sunlight isn't scattered.
17745                                 LightSrc    uint8
17746
17747                                 GndContent   bool
17748                                 Collides     bool
17749                                 Pointable    bool
17750                                 Diggable     bool
17751                                 Climbable    bool
17752                                 Replaceable  bool
17753                                 OnRightClick bool
17754
17755                                 DmgPerSec int32
17756
17757                                 LiquidType   LiquidType
17758                                 FlowingAlt   string
17759                                 SrcAlt       string
17760                                 Viscosity    uint8 // 0-7
17761                                 LiqRenewable bool
17762                                 FlowRange    uint8
17763                                 DrownDmg     uint8
17764                                 Floodable    bool
17765
17766                                 DrawBox, ColBox, SelBox NodeBox
17767
17768                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17769
17770                                 LegacyFaceDir bool
17771                                 LegacyMounted bool
17772
17773                                 DigPredict string
17774
17775                                 MaxLvl uint8
17776
17777                                 AlphaUse
17778
17779                                 MoveResistance uint8
17780
17781                                 LiquidMovePhysics bool
17782                         }))(obj)).Viscosity
17783                         write8(w, uint8(x))
17784                 }
17785                 {
17786                         x := (*(*(struct {
17787                                 Param0 Content
17788
17789                                 Name   string
17790                                 Groups []Group
17791
17792                                 P1Type   Param1Type
17793                                 P2Type   Param2Type
17794                                 DrawType DrawType
17795
17796                                 Mesh  string
17797                                 Scale float32
17798                                 //mt:const uint8(6)
17799                                 Tiles        [6]TileDef
17800                                 OverlayTiles [6]TileDef
17801                                 //mt:const uint8(6)
17802                                 SpecialTiles [6]TileDef
17803
17804                                 Color   color.NRGBA
17805                                 Palette Texture
17806
17807                                 Waving       WaveType
17808                                 ConnectSides uint8
17809                                 ConnectTo    []Content
17810                                 InsideTint   color.NRGBA
17811                                 Level        uint8 // Must be < 128.
17812
17813                                 Translucent bool // Sunlight is scattered and becomes normal light.
17814                                 Transparent bool // Sunlight isn't scattered.
17815                                 LightSrc    uint8
17816
17817                                 GndContent   bool
17818                                 Collides     bool
17819                                 Pointable    bool
17820                                 Diggable     bool
17821                                 Climbable    bool
17822                                 Replaceable  bool
17823                                 OnRightClick bool
17824
17825                                 DmgPerSec int32
17826
17827                                 LiquidType   LiquidType
17828                                 FlowingAlt   string
17829                                 SrcAlt       string
17830                                 Viscosity    uint8 // 0-7
17831                                 LiqRenewable bool
17832                                 FlowRange    uint8
17833                                 DrownDmg     uint8
17834                                 Floodable    bool
17835
17836                                 DrawBox, ColBox, SelBox NodeBox
17837
17838                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17839
17840                                 LegacyFaceDir bool
17841                                 LegacyMounted bool
17842
17843                                 DigPredict string
17844
17845                                 MaxLvl uint8
17846
17847                                 AlphaUse
17848
17849                                 MoveResistance uint8
17850
17851                                 LiquidMovePhysics bool
17852                         }))(obj)).LiqRenewable
17853                         if x {
17854                                 write8(w, 1)
17855                         } else {
17856                                 write8(w, 0)
17857                         }
17858                 }
17859                 {
17860                         x := (*(*(struct {
17861                                 Param0 Content
17862
17863                                 Name   string
17864                                 Groups []Group
17865
17866                                 P1Type   Param1Type
17867                                 P2Type   Param2Type
17868                                 DrawType DrawType
17869
17870                                 Mesh  string
17871                                 Scale float32
17872                                 //mt:const uint8(6)
17873                                 Tiles        [6]TileDef
17874                                 OverlayTiles [6]TileDef
17875                                 //mt:const uint8(6)
17876                                 SpecialTiles [6]TileDef
17877
17878                                 Color   color.NRGBA
17879                                 Palette Texture
17880
17881                                 Waving       WaveType
17882                                 ConnectSides uint8
17883                                 ConnectTo    []Content
17884                                 InsideTint   color.NRGBA
17885                                 Level        uint8 // Must be < 128.
17886
17887                                 Translucent bool // Sunlight is scattered and becomes normal light.
17888                                 Transparent bool // Sunlight isn't scattered.
17889                                 LightSrc    uint8
17890
17891                                 GndContent   bool
17892                                 Collides     bool
17893                                 Pointable    bool
17894                                 Diggable     bool
17895                                 Climbable    bool
17896                                 Replaceable  bool
17897                                 OnRightClick bool
17898
17899                                 DmgPerSec int32
17900
17901                                 LiquidType   LiquidType
17902                                 FlowingAlt   string
17903                                 SrcAlt       string
17904                                 Viscosity    uint8 // 0-7
17905                                 LiqRenewable bool
17906                                 FlowRange    uint8
17907                                 DrownDmg     uint8
17908                                 Floodable    bool
17909
17910                                 DrawBox, ColBox, SelBox NodeBox
17911
17912                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17913
17914                                 LegacyFaceDir bool
17915                                 LegacyMounted bool
17916
17917                                 DigPredict string
17918
17919                                 MaxLvl uint8
17920
17921                                 AlphaUse
17922
17923                                 MoveResistance uint8
17924
17925                                 LiquidMovePhysics bool
17926                         }))(obj)).FlowRange
17927                         write8(w, uint8(x))
17928                 }
17929                 {
17930                         x := (*(*(struct {
17931                                 Param0 Content
17932
17933                                 Name   string
17934                                 Groups []Group
17935
17936                                 P1Type   Param1Type
17937                                 P2Type   Param2Type
17938                                 DrawType DrawType
17939
17940                                 Mesh  string
17941                                 Scale float32
17942                                 //mt:const uint8(6)
17943                                 Tiles        [6]TileDef
17944                                 OverlayTiles [6]TileDef
17945                                 //mt:const uint8(6)
17946                                 SpecialTiles [6]TileDef
17947
17948                                 Color   color.NRGBA
17949                                 Palette Texture
17950
17951                                 Waving       WaveType
17952                                 ConnectSides uint8
17953                                 ConnectTo    []Content
17954                                 InsideTint   color.NRGBA
17955                                 Level        uint8 // Must be < 128.
17956
17957                                 Translucent bool // Sunlight is scattered and becomes normal light.
17958                                 Transparent bool // Sunlight isn't scattered.
17959                                 LightSrc    uint8
17960
17961                                 GndContent   bool
17962                                 Collides     bool
17963                                 Pointable    bool
17964                                 Diggable     bool
17965                                 Climbable    bool
17966                                 Replaceable  bool
17967                                 OnRightClick bool
17968
17969                                 DmgPerSec int32
17970
17971                                 LiquidType   LiquidType
17972                                 FlowingAlt   string
17973                                 SrcAlt       string
17974                                 Viscosity    uint8 // 0-7
17975                                 LiqRenewable bool
17976                                 FlowRange    uint8
17977                                 DrownDmg     uint8
17978                                 Floodable    bool
17979
17980                                 DrawBox, ColBox, SelBox NodeBox
17981
17982                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17983
17984                                 LegacyFaceDir bool
17985                                 LegacyMounted bool
17986
17987                                 DigPredict string
17988
17989                                 MaxLvl uint8
17990
17991                                 AlphaUse
17992
17993                                 MoveResistance uint8
17994
17995                                 LiquidMovePhysics bool
17996                         }))(obj)).DrownDmg
17997                         write8(w, uint8(x))
17998                 }
17999                 {
18000                         x := (*(*(struct {
18001                                 Param0 Content
18002
18003                                 Name   string
18004                                 Groups []Group
18005
18006                                 P1Type   Param1Type
18007                                 P2Type   Param2Type
18008                                 DrawType DrawType
18009
18010                                 Mesh  string
18011                                 Scale float32
18012                                 //mt:const uint8(6)
18013                                 Tiles        [6]TileDef
18014                                 OverlayTiles [6]TileDef
18015                                 //mt:const uint8(6)
18016                                 SpecialTiles [6]TileDef
18017
18018                                 Color   color.NRGBA
18019                                 Palette Texture
18020
18021                                 Waving       WaveType
18022                                 ConnectSides uint8
18023                                 ConnectTo    []Content
18024                                 InsideTint   color.NRGBA
18025                                 Level        uint8 // Must be < 128.
18026
18027                                 Translucent bool // Sunlight is scattered and becomes normal light.
18028                                 Transparent bool // Sunlight isn't scattered.
18029                                 LightSrc    uint8
18030
18031                                 GndContent   bool
18032                                 Collides     bool
18033                                 Pointable    bool
18034                                 Diggable     bool
18035                                 Climbable    bool
18036                                 Replaceable  bool
18037                                 OnRightClick bool
18038
18039                                 DmgPerSec int32
18040
18041                                 LiquidType   LiquidType
18042                                 FlowingAlt   string
18043                                 SrcAlt       string
18044                                 Viscosity    uint8 // 0-7
18045                                 LiqRenewable bool
18046                                 FlowRange    uint8
18047                                 DrownDmg     uint8
18048                                 Floodable    bool
18049
18050                                 DrawBox, ColBox, SelBox NodeBox
18051
18052                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18053
18054                                 LegacyFaceDir bool
18055                                 LegacyMounted bool
18056
18057                                 DigPredict string
18058
18059                                 MaxLvl uint8
18060
18061                                 AlphaUse
18062
18063                                 MoveResistance uint8
18064
18065                                 LiquidMovePhysics bool
18066                         }))(obj)).Floodable
18067                         if x {
18068                                 write8(w, 1)
18069                         } else {
18070                                 write8(w, 0)
18071                         }
18072                 }
18073                 if err := pcall(func() {
18074                         ((*(*(struct {
18075                                 Param0 Content
18076
18077                                 Name   string
18078                                 Groups []Group
18079
18080                                 P1Type   Param1Type
18081                                 P2Type   Param2Type
18082                                 DrawType DrawType
18083
18084                                 Mesh  string
18085                                 Scale float32
18086                                 //mt:const uint8(6)
18087                                 Tiles        [6]TileDef
18088                                 OverlayTiles [6]TileDef
18089                                 //mt:const uint8(6)
18090                                 SpecialTiles [6]TileDef
18091
18092                                 Color   color.NRGBA
18093                                 Palette Texture
18094
18095                                 Waving       WaveType
18096                                 ConnectSides uint8
18097                                 ConnectTo    []Content
18098                                 InsideTint   color.NRGBA
18099                                 Level        uint8 // Must be < 128.
18100
18101                                 Translucent bool // Sunlight is scattered and becomes normal light.
18102                                 Transparent bool // Sunlight isn't scattered.
18103                                 LightSrc    uint8
18104
18105                                 GndContent   bool
18106                                 Collides     bool
18107                                 Pointable    bool
18108                                 Diggable     bool
18109                                 Climbable    bool
18110                                 Replaceable  bool
18111                                 OnRightClick bool
18112
18113                                 DmgPerSec int32
18114
18115                                 LiquidType   LiquidType
18116                                 FlowingAlt   string
18117                                 SrcAlt       string
18118                                 Viscosity    uint8 // 0-7
18119                                 LiqRenewable bool
18120                                 FlowRange    uint8
18121                                 DrownDmg     uint8
18122                                 Floodable    bool
18123
18124                                 DrawBox, ColBox, SelBox NodeBox
18125
18126                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18127
18128                                 LegacyFaceDir bool
18129                                 LegacyMounted bool
18130
18131                                 DigPredict string
18132
18133                                 MaxLvl uint8
18134
18135                                 AlphaUse
18136
18137                                 MoveResistance uint8
18138
18139                                 LiquidMovePhysics bool
18140                         }))(obj)).DrawBox).serialize(w)
18141                 }); err != nil {
18142                         if err == io.EOF {
18143                                 chk(io.EOF)
18144                         }
18145                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18146                 }
18147                 if err := pcall(func() {
18148                         ((*(*(struct {
18149                                 Param0 Content
18150
18151                                 Name   string
18152                                 Groups []Group
18153
18154                                 P1Type   Param1Type
18155                                 P2Type   Param2Type
18156                                 DrawType DrawType
18157
18158                                 Mesh  string
18159                                 Scale float32
18160                                 //mt:const uint8(6)
18161                                 Tiles        [6]TileDef
18162                                 OverlayTiles [6]TileDef
18163                                 //mt:const uint8(6)
18164                                 SpecialTiles [6]TileDef
18165
18166                                 Color   color.NRGBA
18167                                 Palette Texture
18168
18169                                 Waving       WaveType
18170                                 ConnectSides uint8
18171                                 ConnectTo    []Content
18172                                 InsideTint   color.NRGBA
18173                                 Level        uint8 // Must be < 128.
18174
18175                                 Translucent bool // Sunlight is scattered and becomes normal light.
18176                                 Transparent bool // Sunlight isn't scattered.
18177                                 LightSrc    uint8
18178
18179                                 GndContent   bool
18180                                 Collides     bool
18181                                 Pointable    bool
18182                                 Diggable     bool
18183                                 Climbable    bool
18184                                 Replaceable  bool
18185                                 OnRightClick bool
18186
18187                                 DmgPerSec int32
18188
18189                                 LiquidType   LiquidType
18190                                 FlowingAlt   string
18191                                 SrcAlt       string
18192                                 Viscosity    uint8 // 0-7
18193                                 LiqRenewable bool
18194                                 FlowRange    uint8
18195                                 DrownDmg     uint8
18196                                 Floodable    bool
18197
18198                                 DrawBox, ColBox, SelBox NodeBox
18199
18200                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18201
18202                                 LegacyFaceDir bool
18203                                 LegacyMounted bool
18204
18205                                 DigPredict string
18206
18207                                 MaxLvl uint8
18208
18209                                 AlphaUse
18210
18211                                 MoveResistance uint8
18212
18213                                 LiquidMovePhysics bool
18214                         }))(obj)).ColBox).serialize(w)
18215                 }); err != nil {
18216                         if err == io.EOF {
18217                                 chk(io.EOF)
18218                         }
18219                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18220                 }
18221                 if err := pcall(func() {
18222                         ((*(*(struct {
18223                                 Param0 Content
18224
18225                                 Name   string
18226                                 Groups []Group
18227
18228                                 P1Type   Param1Type
18229                                 P2Type   Param2Type
18230                                 DrawType DrawType
18231
18232                                 Mesh  string
18233                                 Scale float32
18234                                 //mt:const uint8(6)
18235                                 Tiles        [6]TileDef
18236                                 OverlayTiles [6]TileDef
18237                                 //mt:const uint8(6)
18238                                 SpecialTiles [6]TileDef
18239
18240                                 Color   color.NRGBA
18241                                 Palette Texture
18242
18243                                 Waving       WaveType
18244                                 ConnectSides uint8
18245                                 ConnectTo    []Content
18246                                 InsideTint   color.NRGBA
18247                                 Level        uint8 // Must be < 128.
18248
18249                                 Translucent bool // Sunlight is scattered and becomes normal light.
18250                                 Transparent bool // Sunlight isn't scattered.
18251                                 LightSrc    uint8
18252
18253                                 GndContent   bool
18254                                 Collides     bool
18255                                 Pointable    bool
18256                                 Diggable     bool
18257                                 Climbable    bool
18258                                 Replaceable  bool
18259                                 OnRightClick bool
18260
18261                                 DmgPerSec int32
18262
18263                                 LiquidType   LiquidType
18264                                 FlowingAlt   string
18265                                 SrcAlt       string
18266                                 Viscosity    uint8 // 0-7
18267                                 LiqRenewable bool
18268                                 FlowRange    uint8
18269                                 DrownDmg     uint8
18270                                 Floodable    bool
18271
18272                                 DrawBox, ColBox, SelBox NodeBox
18273
18274                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18275
18276                                 LegacyFaceDir bool
18277                                 LegacyMounted bool
18278
18279                                 DigPredict string
18280
18281                                 MaxLvl uint8
18282
18283                                 AlphaUse
18284
18285                                 MoveResistance uint8
18286
18287                                 LiquidMovePhysics bool
18288                         }))(obj)).SelBox).serialize(w)
18289                 }); err != nil {
18290                         if err == io.EOF {
18291                                 chk(io.EOF)
18292                         }
18293                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18294                 }
18295                 if err := pcall(func() {
18296                         ((*(*(struct {
18297                                 Param0 Content
18298
18299                                 Name   string
18300                                 Groups []Group
18301
18302                                 P1Type   Param1Type
18303                                 P2Type   Param2Type
18304                                 DrawType DrawType
18305
18306                                 Mesh  string
18307                                 Scale float32
18308                                 //mt:const uint8(6)
18309                                 Tiles        [6]TileDef
18310                                 OverlayTiles [6]TileDef
18311                                 //mt:const uint8(6)
18312                                 SpecialTiles [6]TileDef
18313
18314                                 Color   color.NRGBA
18315                                 Palette Texture
18316
18317                                 Waving       WaveType
18318                                 ConnectSides uint8
18319                                 ConnectTo    []Content
18320                                 InsideTint   color.NRGBA
18321                                 Level        uint8 // Must be < 128.
18322
18323                                 Translucent bool // Sunlight is scattered and becomes normal light.
18324                                 Transparent bool // Sunlight isn't scattered.
18325                                 LightSrc    uint8
18326
18327                                 GndContent   bool
18328                                 Collides     bool
18329                                 Pointable    bool
18330                                 Diggable     bool
18331                                 Climbable    bool
18332                                 Replaceable  bool
18333                                 OnRightClick bool
18334
18335                                 DmgPerSec int32
18336
18337                                 LiquidType   LiquidType
18338                                 FlowingAlt   string
18339                                 SrcAlt       string
18340                                 Viscosity    uint8 // 0-7
18341                                 LiqRenewable bool
18342                                 FlowRange    uint8
18343                                 DrownDmg     uint8
18344                                 Floodable    bool
18345
18346                                 DrawBox, ColBox, SelBox NodeBox
18347
18348                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18349
18350                                 LegacyFaceDir bool
18351                                 LegacyMounted bool
18352
18353                                 DigPredict string
18354
18355                                 MaxLvl uint8
18356
18357                                 AlphaUse
18358
18359                                 MoveResistance uint8
18360
18361                                 LiquidMovePhysics bool
18362                         }))(obj)).FootstepSnd).serialize(w)
18363                 }); err != nil {
18364                         if err == io.EOF {
18365                                 chk(io.EOF)
18366                         }
18367                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18368                 }
18369                 if err := pcall(func() {
18370                         ((*(*(struct {
18371                                 Param0 Content
18372
18373                                 Name   string
18374                                 Groups []Group
18375
18376                                 P1Type   Param1Type
18377                                 P2Type   Param2Type
18378                                 DrawType DrawType
18379
18380                                 Mesh  string
18381                                 Scale float32
18382                                 //mt:const uint8(6)
18383                                 Tiles        [6]TileDef
18384                                 OverlayTiles [6]TileDef
18385                                 //mt:const uint8(6)
18386                                 SpecialTiles [6]TileDef
18387
18388                                 Color   color.NRGBA
18389                                 Palette Texture
18390
18391                                 Waving       WaveType
18392                                 ConnectSides uint8
18393                                 ConnectTo    []Content
18394                                 InsideTint   color.NRGBA
18395                                 Level        uint8 // Must be < 128.
18396
18397                                 Translucent bool // Sunlight is scattered and becomes normal light.
18398                                 Transparent bool // Sunlight isn't scattered.
18399                                 LightSrc    uint8
18400
18401                                 GndContent   bool
18402                                 Collides     bool
18403                                 Pointable    bool
18404                                 Diggable     bool
18405                                 Climbable    bool
18406                                 Replaceable  bool
18407                                 OnRightClick bool
18408
18409                                 DmgPerSec int32
18410
18411                                 LiquidType   LiquidType
18412                                 FlowingAlt   string
18413                                 SrcAlt       string
18414                                 Viscosity    uint8 // 0-7
18415                                 LiqRenewable bool
18416                                 FlowRange    uint8
18417                                 DrownDmg     uint8
18418                                 Floodable    bool
18419
18420                                 DrawBox, ColBox, SelBox NodeBox
18421
18422                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18423
18424                                 LegacyFaceDir bool
18425                                 LegacyMounted bool
18426
18427                                 DigPredict string
18428
18429                                 MaxLvl uint8
18430
18431                                 AlphaUse
18432
18433                                 MoveResistance uint8
18434
18435                                 LiquidMovePhysics bool
18436                         }))(obj)).DiggingSnd).serialize(w)
18437                 }); err != nil {
18438                         if err == io.EOF {
18439                                 chk(io.EOF)
18440                         }
18441                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18442                 }
18443                 if err := pcall(func() {
18444                         ((*(*(struct {
18445                                 Param0 Content
18446
18447                                 Name   string
18448                                 Groups []Group
18449
18450                                 P1Type   Param1Type
18451                                 P2Type   Param2Type
18452                                 DrawType DrawType
18453
18454                                 Mesh  string
18455                                 Scale float32
18456                                 //mt:const uint8(6)
18457                                 Tiles        [6]TileDef
18458                                 OverlayTiles [6]TileDef
18459                                 //mt:const uint8(6)
18460                                 SpecialTiles [6]TileDef
18461
18462                                 Color   color.NRGBA
18463                                 Palette Texture
18464
18465                                 Waving       WaveType
18466                                 ConnectSides uint8
18467                                 ConnectTo    []Content
18468                                 InsideTint   color.NRGBA
18469                                 Level        uint8 // Must be < 128.
18470
18471                                 Translucent bool // Sunlight is scattered and becomes normal light.
18472                                 Transparent bool // Sunlight isn't scattered.
18473                                 LightSrc    uint8
18474
18475                                 GndContent   bool
18476                                 Collides     bool
18477                                 Pointable    bool
18478                                 Diggable     bool
18479                                 Climbable    bool
18480                                 Replaceable  bool
18481                                 OnRightClick bool
18482
18483                                 DmgPerSec int32
18484
18485                                 LiquidType   LiquidType
18486                                 FlowingAlt   string
18487                                 SrcAlt       string
18488                                 Viscosity    uint8 // 0-7
18489                                 LiqRenewable bool
18490                                 FlowRange    uint8
18491                                 DrownDmg     uint8
18492                                 Floodable    bool
18493
18494                                 DrawBox, ColBox, SelBox NodeBox
18495
18496                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18497
18498                                 LegacyFaceDir bool
18499                                 LegacyMounted bool
18500
18501                                 DigPredict string
18502
18503                                 MaxLvl uint8
18504
18505                                 AlphaUse
18506
18507                                 MoveResistance uint8
18508
18509                                 LiquidMovePhysics bool
18510                         }))(obj)).DugSnd).serialize(w)
18511                 }); err != nil {
18512                         if err == io.EOF {
18513                                 chk(io.EOF)
18514                         }
18515                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18516                 }
18517                 {
18518                         x := (*(*(struct {
18519                                 Param0 Content
18520
18521                                 Name   string
18522                                 Groups []Group
18523
18524                                 P1Type   Param1Type
18525                                 P2Type   Param2Type
18526                                 DrawType DrawType
18527
18528                                 Mesh  string
18529                                 Scale float32
18530                                 //mt:const uint8(6)
18531                                 Tiles        [6]TileDef
18532                                 OverlayTiles [6]TileDef
18533                                 //mt:const uint8(6)
18534                                 SpecialTiles [6]TileDef
18535
18536                                 Color   color.NRGBA
18537                                 Palette Texture
18538
18539                                 Waving       WaveType
18540                                 ConnectSides uint8
18541                                 ConnectTo    []Content
18542                                 InsideTint   color.NRGBA
18543                                 Level        uint8 // Must be < 128.
18544
18545                                 Translucent bool // Sunlight is scattered and becomes normal light.
18546                                 Transparent bool // Sunlight isn't scattered.
18547                                 LightSrc    uint8
18548
18549                                 GndContent   bool
18550                                 Collides     bool
18551                                 Pointable    bool
18552                                 Diggable     bool
18553                                 Climbable    bool
18554                                 Replaceable  bool
18555                                 OnRightClick bool
18556
18557                                 DmgPerSec int32
18558
18559                                 LiquidType   LiquidType
18560                                 FlowingAlt   string
18561                                 SrcAlt       string
18562                                 Viscosity    uint8 // 0-7
18563                                 LiqRenewable bool
18564                                 FlowRange    uint8
18565                                 DrownDmg     uint8
18566                                 Floodable    bool
18567
18568                                 DrawBox, ColBox, SelBox NodeBox
18569
18570                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18571
18572                                 LegacyFaceDir bool
18573                                 LegacyMounted bool
18574
18575                                 DigPredict string
18576
18577                                 MaxLvl uint8
18578
18579                                 AlphaUse
18580
18581                                 MoveResistance uint8
18582
18583                                 LiquidMovePhysics bool
18584                         }))(obj)).LegacyFaceDir
18585                         if x {
18586                                 write8(w, 1)
18587                         } else {
18588                                 write8(w, 0)
18589                         }
18590                 }
18591                 {
18592                         x := (*(*(struct {
18593                                 Param0 Content
18594
18595                                 Name   string
18596                                 Groups []Group
18597
18598                                 P1Type   Param1Type
18599                                 P2Type   Param2Type
18600                                 DrawType DrawType
18601
18602                                 Mesh  string
18603                                 Scale float32
18604                                 //mt:const uint8(6)
18605                                 Tiles        [6]TileDef
18606                                 OverlayTiles [6]TileDef
18607                                 //mt:const uint8(6)
18608                                 SpecialTiles [6]TileDef
18609
18610                                 Color   color.NRGBA
18611                                 Palette Texture
18612
18613                                 Waving       WaveType
18614                                 ConnectSides uint8
18615                                 ConnectTo    []Content
18616                                 InsideTint   color.NRGBA
18617                                 Level        uint8 // Must be < 128.
18618
18619                                 Translucent bool // Sunlight is scattered and becomes normal light.
18620                                 Transparent bool // Sunlight isn't scattered.
18621                                 LightSrc    uint8
18622
18623                                 GndContent   bool
18624                                 Collides     bool
18625                                 Pointable    bool
18626                                 Diggable     bool
18627                                 Climbable    bool
18628                                 Replaceable  bool
18629                                 OnRightClick bool
18630
18631                                 DmgPerSec int32
18632
18633                                 LiquidType   LiquidType
18634                                 FlowingAlt   string
18635                                 SrcAlt       string
18636                                 Viscosity    uint8 // 0-7
18637                                 LiqRenewable bool
18638                                 FlowRange    uint8
18639                                 DrownDmg     uint8
18640                                 Floodable    bool
18641
18642                                 DrawBox, ColBox, SelBox NodeBox
18643
18644                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18645
18646                                 LegacyFaceDir bool
18647                                 LegacyMounted bool
18648
18649                                 DigPredict string
18650
18651                                 MaxLvl uint8
18652
18653                                 AlphaUse
18654
18655                                 MoveResistance uint8
18656
18657                                 LiquidMovePhysics bool
18658                         }))(obj)).LegacyMounted
18659                         if x {
18660                                 write8(w, 1)
18661                         } else {
18662                                 write8(w, 0)
18663                         }
18664                 }
18665                 if len(([]byte((*(*(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
18728                         MoveResistance uint8
18729
18730                         LiquidMovePhysics bool
18731                 }))(obj)).DigPredict))) > math.MaxUint16 {
18732                         chk(ErrTooLong)
18733                 }
18734                 {
18735                         x := uint16(len(([]byte((*(*(struct {
18736                                 Param0 Content
18737
18738                                 Name   string
18739                                 Groups []Group
18740
18741                                 P1Type   Param1Type
18742                                 P2Type   Param2Type
18743                                 DrawType DrawType
18744
18745                                 Mesh  string
18746                                 Scale float32
18747                                 //mt:const uint8(6)
18748                                 Tiles        [6]TileDef
18749                                 OverlayTiles [6]TileDef
18750                                 //mt:const uint8(6)
18751                                 SpecialTiles [6]TileDef
18752
18753                                 Color   color.NRGBA
18754                                 Palette Texture
18755
18756                                 Waving       WaveType
18757                                 ConnectSides uint8
18758                                 ConnectTo    []Content
18759                                 InsideTint   color.NRGBA
18760                                 Level        uint8 // Must be < 128.
18761
18762                                 Translucent bool // Sunlight is scattered and becomes normal light.
18763                                 Transparent bool // Sunlight isn't scattered.
18764                                 LightSrc    uint8
18765
18766                                 GndContent   bool
18767                                 Collides     bool
18768                                 Pointable    bool
18769                                 Diggable     bool
18770                                 Climbable    bool
18771                                 Replaceable  bool
18772                                 OnRightClick bool
18773
18774                                 DmgPerSec int32
18775
18776                                 LiquidType   LiquidType
18777                                 FlowingAlt   string
18778                                 SrcAlt       string
18779                                 Viscosity    uint8 // 0-7
18780                                 LiqRenewable bool
18781                                 FlowRange    uint8
18782                                 DrownDmg     uint8
18783                                 Floodable    bool
18784
18785                                 DrawBox, ColBox, SelBox NodeBox
18786
18787                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18788
18789                                 LegacyFaceDir bool
18790                                 LegacyMounted bool
18791
18792                                 DigPredict string
18793
18794                                 MaxLvl uint8
18795
18796                                 AlphaUse
18797
18798                                 MoveResistance uint8
18799
18800                                 LiquidMovePhysics bool
18801                         }))(obj)).DigPredict))))
18802                         write16(w, uint16(x))
18803                 }
18804                 {
18805                         _, err := w.Write(([]byte((*(*(struct {
18806                                 Param0 Content
18807
18808                                 Name   string
18809                                 Groups []Group
18810
18811                                 P1Type   Param1Type
18812                                 P2Type   Param2Type
18813                                 DrawType DrawType
18814
18815                                 Mesh  string
18816                                 Scale float32
18817                                 //mt:const uint8(6)
18818                                 Tiles        [6]TileDef
18819                                 OverlayTiles [6]TileDef
18820                                 //mt:const uint8(6)
18821                                 SpecialTiles [6]TileDef
18822
18823                                 Color   color.NRGBA
18824                                 Palette Texture
18825
18826                                 Waving       WaveType
18827                                 ConnectSides uint8
18828                                 ConnectTo    []Content
18829                                 InsideTint   color.NRGBA
18830                                 Level        uint8 // Must be < 128.
18831
18832                                 Translucent bool // Sunlight is scattered and becomes normal light.
18833                                 Transparent bool // Sunlight isn't scattered.
18834                                 LightSrc    uint8
18835
18836                                 GndContent   bool
18837                                 Collides     bool
18838                                 Pointable    bool
18839                                 Diggable     bool
18840                                 Climbable    bool
18841                                 Replaceable  bool
18842                                 OnRightClick bool
18843
18844                                 DmgPerSec int32
18845
18846                                 LiquidType   LiquidType
18847                                 FlowingAlt   string
18848                                 SrcAlt       string
18849                                 Viscosity    uint8 // 0-7
18850                                 LiqRenewable bool
18851                                 FlowRange    uint8
18852                                 DrownDmg     uint8
18853                                 Floodable    bool
18854
18855                                 DrawBox, ColBox, SelBox NodeBox
18856
18857                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18858
18859                                 LegacyFaceDir bool
18860                                 LegacyMounted bool
18861
18862                                 DigPredict string
18863
18864                                 MaxLvl uint8
18865
18866                                 AlphaUse
18867
18868                                 MoveResistance uint8
18869
18870                                 LiquidMovePhysics bool
18871                         }))(obj)).DigPredict))[:])
18872                         chk(err)
18873                 }
18874                 {
18875                         x := (*(*(struct {
18876                                 Param0 Content
18877
18878                                 Name   string
18879                                 Groups []Group
18880
18881                                 P1Type   Param1Type
18882                                 P2Type   Param2Type
18883                                 DrawType DrawType
18884
18885                                 Mesh  string
18886                                 Scale float32
18887                                 //mt:const uint8(6)
18888                                 Tiles        [6]TileDef
18889                                 OverlayTiles [6]TileDef
18890                                 //mt:const uint8(6)
18891                                 SpecialTiles [6]TileDef
18892
18893                                 Color   color.NRGBA
18894                                 Palette Texture
18895
18896                                 Waving       WaveType
18897                                 ConnectSides uint8
18898                                 ConnectTo    []Content
18899                                 InsideTint   color.NRGBA
18900                                 Level        uint8 // Must be < 128.
18901
18902                                 Translucent bool // Sunlight is scattered and becomes normal light.
18903                                 Transparent bool // Sunlight isn't scattered.
18904                                 LightSrc    uint8
18905
18906                                 GndContent   bool
18907                                 Collides     bool
18908                                 Pointable    bool
18909                                 Diggable     bool
18910                                 Climbable    bool
18911                                 Replaceable  bool
18912                                 OnRightClick bool
18913
18914                                 DmgPerSec int32
18915
18916                                 LiquidType   LiquidType
18917                                 FlowingAlt   string
18918                                 SrcAlt       string
18919                                 Viscosity    uint8 // 0-7
18920                                 LiqRenewable bool
18921                                 FlowRange    uint8
18922                                 DrownDmg     uint8
18923                                 Floodable    bool
18924
18925                                 DrawBox, ColBox, SelBox NodeBox
18926
18927                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18928
18929                                 LegacyFaceDir bool
18930                                 LegacyMounted bool
18931
18932                                 DigPredict string
18933
18934                                 MaxLvl uint8
18935
18936                                 AlphaUse
18937
18938                                 MoveResistance uint8
18939
18940                                 LiquidMovePhysics bool
18941                         }))(obj)).MaxLvl
18942                         write8(w, uint8(x))
18943                 }
18944                 if err := pcall(func() {
18945                         ((*(*(struct {
18946                                 Param0 Content
18947
18948                                 Name   string
18949                                 Groups []Group
18950
18951                                 P1Type   Param1Type
18952                                 P2Type   Param2Type
18953                                 DrawType DrawType
18954
18955                                 Mesh  string
18956                                 Scale float32
18957                                 //mt:const uint8(6)
18958                                 Tiles        [6]TileDef
18959                                 OverlayTiles [6]TileDef
18960                                 //mt:const uint8(6)
18961                                 SpecialTiles [6]TileDef
18962
18963                                 Color   color.NRGBA
18964                                 Palette Texture
18965
18966                                 Waving       WaveType
18967                                 ConnectSides uint8
18968                                 ConnectTo    []Content
18969                                 InsideTint   color.NRGBA
18970                                 Level        uint8 // Must be < 128.
18971
18972                                 Translucent bool // Sunlight is scattered and becomes normal light.
18973                                 Transparent bool // Sunlight isn't scattered.
18974                                 LightSrc    uint8
18975
18976                                 GndContent   bool
18977                                 Collides     bool
18978                                 Pointable    bool
18979                                 Diggable     bool
18980                                 Climbable    bool
18981                                 Replaceable  bool
18982                                 OnRightClick bool
18983
18984                                 DmgPerSec int32
18985
18986                                 LiquidType   LiquidType
18987                                 FlowingAlt   string
18988                                 SrcAlt       string
18989                                 Viscosity    uint8 // 0-7
18990                                 LiqRenewable bool
18991                                 FlowRange    uint8
18992                                 DrownDmg     uint8
18993                                 Floodable    bool
18994
18995                                 DrawBox, ColBox, SelBox NodeBox
18996
18997                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18998
18999                                 LegacyFaceDir bool
19000                                 LegacyMounted bool
19001
19002                                 DigPredict string
19003
19004                                 MaxLvl uint8
19005
19006                                 AlphaUse
19007
19008                                 MoveResistance uint8
19009
19010                                 LiquidMovePhysics bool
19011                         }))(obj)).AlphaUse).serialize(w)
19012                 }); err != nil {
19013                         if err == io.EOF {
19014                                 chk(io.EOF)
19015                         }
19016                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlphaUse", err))
19017                 }
19018                 {
19019                         x := (*(*(struct {
19020                                 Param0 Content
19021
19022                                 Name   string
19023                                 Groups []Group
19024
19025                                 P1Type   Param1Type
19026                                 P2Type   Param2Type
19027                                 DrawType DrawType
19028
19029                                 Mesh  string
19030                                 Scale float32
19031                                 //mt:const uint8(6)
19032                                 Tiles        [6]TileDef
19033                                 OverlayTiles [6]TileDef
19034                                 //mt:const uint8(6)
19035                                 SpecialTiles [6]TileDef
19036
19037                                 Color   color.NRGBA
19038                                 Palette Texture
19039
19040                                 Waving       WaveType
19041                                 ConnectSides uint8
19042                                 ConnectTo    []Content
19043                                 InsideTint   color.NRGBA
19044                                 Level        uint8 // Must be < 128.
19045
19046                                 Translucent bool // Sunlight is scattered and becomes normal light.
19047                                 Transparent bool // Sunlight isn't scattered.
19048                                 LightSrc    uint8
19049
19050                                 GndContent   bool
19051                                 Collides     bool
19052                                 Pointable    bool
19053                                 Diggable     bool
19054                                 Climbable    bool
19055                                 Replaceable  bool
19056                                 OnRightClick bool
19057
19058                                 DmgPerSec int32
19059
19060                                 LiquidType   LiquidType
19061                                 FlowingAlt   string
19062                                 SrcAlt       string
19063                                 Viscosity    uint8 // 0-7
19064                                 LiqRenewable bool
19065                                 FlowRange    uint8
19066                                 DrownDmg     uint8
19067                                 Floodable    bool
19068
19069                                 DrawBox, ColBox, SelBox NodeBox
19070
19071                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19072
19073                                 LegacyFaceDir bool
19074                                 LegacyMounted bool
19075
19076                                 DigPredict string
19077
19078                                 MaxLvl uint8
19079
19080                                 AlphaUse
19081
19082                                 MoveResistance uint8
19083
19084                                 LiquidMovePhysics bool
19085                         }))(obj)).MoveResistance
19086                         write8(w, uint8(x))
19087                 }
19088                 {
19089                         x := (*(*(struct {
19090                                 Param0 Content
19091
19092                                 Name   string
19093                                 Groups []Group
19094
19095                                 P1Type   Param1Type
19096                                 P2Type   Param2Type
19097                                 DrawType DrawType
19098
19099                                 Mesh  string
19100                                 Scale float32
19101                                 //mt:const uint8(6)
19102                                 Tiles        [6]TileDef
19103                                 OverlayTiles [6]TileDef
19104                                 //mt:const uint8(6)
19105                                 SpecialTiles [6]TileDef
19106
19107                                 Color   color.NRGBA
19108                                 Palette Texture
19109
19110                                 Waving       WaveType
19111                                 ConnectSides uint8
19112                                 ConnectTo    []Content
19113                                 InsideTint   color.NRGBA
19114                                 Level        uint8 // Must be < 128.
19115
19116                                 Translucent bool // Sunlight is scattered and becomes normal light.
19117                                 Transparent bool // Sunlight isn't scattered.
19118                                 LightSrc    uint8
19119
19120                                 GndContent   bool
19121                                 Collides     bool
19122                                 Pointable    bool
19123                                 Diggable     bool
19124                                 Climbable    bool
19125                                 Replaceable  bool
19126                                 OnRightClick bool
19127
19128                                 DmgPerSec int32
19129
19130                                 LiquidType   LiquidType
19131                                 FlowingAlt   string
19132                                 SrcAlt       string
19133                                 Viscosity    uint8 // 0-7
19134                                 LiqRenewable bool
19135                                 FlowRange    uint8
19136                                 DrownDmg     uint8
19137                                 Floodable    bool
19138
19139                                 DrawBox, ColBox, SelBox NodeBox
19140
19141                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19142
19143                                 LegacyFaceDir bool
19144                                 LegacyMounted bool
19145
19146                                 DigPredict string
19147
19148                                 MaxLvl uint8
19149
19150                                 AlphaUse
19151
19152                                 MoveResistance uint8
19153
19154                                 LiquidMovePhysics bool
19155                         }))(obj)).LiquidMovePhysics
19156                         if x {
19157                                 write8(w, 1)
19158                         } else {
19159                                 write8(w, 0)
19160                         }
19161                 }
19162                 {
19163                         buf := w
19164                         w := ow
19165                         if len((buf.Bytes())) > math.MaxUint16 {
19166                                 chk(ErrTooLong)
19167                         }
19168                         {
19169                                 x := uint16(len((buf.Bytes())))
19170                                 write16(w, uint16(x))
19171                         }
19172                         {
19173                                 _, err := w.Write((buf.Bytes())[:])
19174                                 chk(err)
19175                         }
19176                 }
19177         }
19178 }
19179
19180 func (obj *NodeDef) deserialize(r io.Reader) {
19181         if err := pcall(func() {
19182                 ((*(*(struct {
19183                         Param0 Content
19184
19185                         Name   string
19186                         Groups []Group
19187
19188                         P1Type   Param1Type
19189                         P2Type   Param2Type
19190                         DrawType DrawType
19191
19192                         Mesh  string
19193                         Scale float32
19194                         //mt:const uint8(6)
19195                         Tiles        [6]TileDef
19196                         OverlayTiles [6]TileDef
19197                         //mt:const uint8(6)
19198                         SpecialTiles [6]TileDef
19199
19200                         Color   color.NRGBA
19201                         Palette Texture
19202
19203                         Waving       WaveType
19204                         ConnectSides uint8
19205                         ConnectTo    []Content
19206                         InsideTint   color.NRGBA
19207                         Level        uint8 // Must be < 128.
19208
19209                         Translucent bool // Sunlight is scattered and becomes normal light.
19210                         Transparent bool // Sunlight isn't scattered.
19211                         LightSrc    uint8
19212
19213                         GndContent   bool
19214                         Collides     bool
19215                         Pointable    bool
19216                         Diggable     bool
19217                         Climbable    bool
19218                         Replaceable  bool
19219                         OnRightClick bool
19220
19221                         DmgPerSec int32
19222
19223                         LiquidType   LiquidType
19224                         FlowingAlt   string
19225                         SrcAlt       string
19226                         Viscosity    uint8 // 0-7
19227                         LiqRenewable bool
19228                         FlowRange    uint8
19229                         DrownDmg     uint8
19230                         Floodable    bool
19231
19232                         DrawBox, ColBox, SelBox NodeBox
19233
19234                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19235
19236                         LegacyFaceDir bool
19237                         LegacyMounted bool
19238
19239                         DigPredict string
19240
19241                         MaxLvl uint8
19242
19243                         AlphaUse
19244
19245                         MoveResistance uint8
19246
19247                         LiquidMovePhysics bool
19248                 }))(obj)).Param0).deserialize(r)
19249         }); err != nil {
19250                 if err == io.EOF {
19251                         chk(io.EOF)
19252                 }
19253                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
19254         }
19255         {
19256                 var n uint16
19257                 {
19258                         p := &n
19259                         *p = read16(r)
19260                 }
19261                 r := &io.LimitedReader{R: r, N: int64(n)}
19262                 {
19263                         var local246 uint8
19264                         local247 := uint8(13)
19265                         {
19266                                 p := &local246
19267                                 *p = read8(r)
19268                         }
19269                         if local246 != local247 {
19270                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local246))
19271                         }
19272                 }
19273                 var local248 []uint8
19274                 var local249 uint16
19275                 {
19276                         p := &local249
19277                         *p = read16(r)
19278                 }
19279                 (local248) = make([]uint8, local249)
19280                 {
19281                         _, err := io.ReadFull(r, (local248)[:])
19282                         chk(err)
19283                 }
19284                 ((*(*(struct {
19285                         Param0 Content
19286
19287                         Name   string
19288                         Groups []Group
19289
19290                         P1Type   Param1Type
19291                         P2Type   Param2Type
19292                         DrawType DrawType
19293
19294                         Mesh  string
19295                         Scale float32
19296                         //mt:const uint8(6)
19297                         Tiles        [6]TileDef
19298                         OverlayTiles [6]TileDef
19299                         //mt:const uint8(6)
19300                         SpecialTiles [6]TileDef
19301
19302                         Color   color.NRGBA
19303                         Palette Texture
19304
19305                         Waving       WaveType
19306                         ConnectSides uint8
19307                         ConnectTo    []Content
19308                         InsideTint   color.NRGBA
19309                         Level        uint8 // Must be < 128.
19310
19311                         Translucent bool // Sunlight is scattered and becomes normal light.
19312                         Transparent bool // Sunlight isn't scattered.
19313                         LightSrc    uint8
19314
19315                         GndContent   bool
19316                         Collides     bool
19317                         Pointable    bool
19318                         Diggable     bool
19319                         Climbable    bool
19320                         Replaceable  bool
19321                         OnRightClick bool
19322
19323                         DmgPerSec int32
19324
19325                         LiquidType   LiquidType
19326                         FlowingAlt   string
19327                         SrcAlt       string
19328                         Viscosity    uint8 // 0-7
19329                         LiqRenewable bool
19330                         FlowRange    uint8
19331                         DrownDmg     uint8
19332                         Floodable    bool
19333
19334                         DrawBox, ColBox, SelBox NodeBox
19335
19336                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19337
19338                         LegacyFaceDir bool
19339                         LegacyMounted bool
19340
19341                         DigPredict string
19342
19343                         MaxLvl uint8
19344
19345                         AlphaUse
19346
19347                         MoveResistance uint8
19348
19349                         LiquidMovePhysics bool
19350                 }))(obj)).Name) = string(local248)
19351                 var local250 uint16
19352                 {
19353                         p := &local250
19354                         *p = read16(r)
19355                 }
19356                 ((*(*(struct {
19357                         Param0 Content
19358
19359                         Name   string
19360                         Groups []Group
19361
19362                         P1Type   Param1Type
19363                         P2Type   Param2Type
19364                         DrawType DrawType
19365
19366                         Mesh  string
19367                         Scale float32
19368                         //mt:const uint8(6)
19369                         Tiles        [6]TileDef
19370                         OverlayTiles [6]TileDef
19371                         //mt:const uint8(6)
19372                         SpecialTiles [6]TileDef
19373
19374                         Color   color.NRGBA
19375                         Palette Texture
19376
19377                         Waving       WaveType
19378                         ConnectSides uint8
19379                         ConnectTo    []Content
19380                         InsideTint   color.NRGBA
19381                         Level        uint8 // Must be < 128.
19382
19383                         Translucent bool // Sunlight is scattered and becomes normal light.
19384                         Transparent bool // Sunlight isn't scattered.
19385                         LightSrc    uint8
19386
19387                         GndContent   bool
19388                         Collides     bool
19389                         Pointable    bool
19390                         Diggable     bool
19391                         Climbable    bool
19392                         Replaceable  bool
19393                         OnRightClick bool
19394
19395                         DmgPerSec int32
19396
19397                         LiquidType   LiquidType
19398                         FlowingAlt   string
19399                         SrcAlt       string
19400                         Viscosity    uint8 // 0-7
19401                         LiqRenewable bool
19402                         FlowRange    uint8
19403                         DrownDmg     uint8
19404                         Floodable    bool
19405
19406                         DrawBox, ColBox, SelBox NodeBox
19407
19408                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19409
19410                         LegacyFaceDir bool
19411                         LegacyMounted bool
19412
19413                         DigPredict string
19414
19415                         MaxLvl uint8
19416
19417                         AlphaUse
19418
19419                         MoveResistance uint8
19420
19421                         LiquidMovePhysics bool
19422                 }))(obj)).Groups) = make([]Group, local250)
19423                 for local251 := range (*(*(struct {
19424                         Param0 Content
19425
19426                         Name   string
19427                         Groups []Group
19428
19429                         P1Type   Param1Type
19430                         P2Type   Param2Type
19431                         DrawType DrawType
19432
19433                         Mesh  string
19434                         Scale float32
19435                         //mt:const uint8(6)
19436                         Tiles        [6]TileDef
19437                         OverlayTiles [6]TileDef
19438                         //mt:const uint8(6)
19439                         SpecialTiles [6]TileDef
19440
19441                         Color   color.NRGBA
19442                         Palette Texture
19443
19444                         Waving       WaveType
19445                         ConnectSides uint8
19446                         ConnectTo    []Content
19447                         InsideTint   color.NRGBA
19448                         Level        uint8 // Must be < 128.
19449
19450                         Translucent bool // Sunlight is scattered and becomes normal light.
19451                         Transparent bool // Sunlight isn't scattered.
19452                         LightSrc    uint8
19453
19454                         GndContent   bool
19455                         Collides     bool
19456                         Pointable    bool
19457                         Diggable     bool
19458                         Climbable    bool
19459                         Replaceable  bool
19460                         OnRightClick bool
19461
19462                         DmgPerSec int32
19463
19464                         LiquidType   LiquidType
19465                         FlowingAlt   string
19466                         SrcAlt       string
19467                         Viscosity    uint8 // 0-7
19468                         LiqRenewable bool
19469                         FlowRange    uint8
19470                         DrownDmg     uint8
19471                         Floodable    bool
19472
19473                         DrawBox, ColBox, SelBox NodeBox
19474
19475                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19476
19477                         LegacyFaceDir bool
19478                         LegacyMounted bool
19479
19480                         DigPredict string
19481
19482                         MaxLvl uint8
19483
19484                         AlphaUse
19485
19486                         MoveResistance uint8
19487
19488                         LiquidMovePhysics bool
19489                 }))(obj)).Groups {
19490                         if err := pcall(func() {
19491                                 (((*(*(struct {
19492                                         Param0 Content
19493
19494                                         Name   string
19495                                         Groups []Group
19496
19497                                         P1Type   Param1Type
19498                                         P2Type   Param2Type
19499                                         DrawType DrawType
19500
19501                                         Mesh  string
19502                                         Scale float32
19503                                         //mt:const uint8(6)
19504                                         Tiles        [6]TileDef
19505                                         OverlayTiles [6]TileDef
19506                                         //mt:const uint8(6)
19507                                         SpecialTiles [6]TileDef
19508
19509                                         Color   color.NRGBA
19510                                         Palette Texture
19511
19512                                         Waving       WaveType
19513                                         ConnectSides uint8
19514                                         ConnectTo    []Content
19515                                         InsideTint   color.NRGBA
19516                                         Level        uint8 // Must be < 128.
19517
19518                                         Translucent bool // Sunlight is scattered and becomes normal light.
19519                                         Transparent bool // Sunlight isn't scattered.
19520                                         LightSrc    uint8
19521
19522                                         GndContent   bool
19523                                         Collides     bool
19524                                         Pointable    bool
19525                                         Diggable     bool
19526                                         Climbable    bool
19527                                         Replaceable  bool
19528                                         OnRightClick bool
19529
19530                                         DmgPerSec int32
19531
19532                                         LiquidType   LiquidType
19533                                         FlowingAlt   string
19534                                         SrcAlt       string
19535                                         Viscosity    uint8 // 0-7
19536                                         LiqRenewable bool
19537                                         FlowRange    uint8
19538                                         DrownDmg     uint8
19539                                         Floodable    bool
19540
19541                                         DrawBox, ColBox, SelBox NodeBox
19542
19543                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19544
19545                                         LegacyFaceDir bool
19546                                         LegacyMounted bool
19547
19548                                         DigPredict string
19549
19550                                         MaxLvl uint8
19551
19552                                         AlphaUse
19553
19554                                         MoveResistance uint8
19555
19556                                         LiquidMovePhysics bool
19557                                 }))(obj)).Groups)[local251]).deserialize(r)
19558                         }); err != nil {
19559                                 if err == io.EOF {
19560                                         chk(io.EOF)
19561                                 }
19562                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
19563                         }
19564                 }
19565                 if err := pcall(func() {
19566                         ((*(*(struct {
19567                                 Param0 Content
19568
19569                                 Name   string
19570                                 Groups []Group
19571
19572                                 P1Type   Param1Type
19573                                 P2Type   Param2Type
19574                                 DrawType DrawType
19575
19576                                 Mesh  string
19577                                 Scale float32
19578                                 //mt:const uint8(6)
19579                                 Tiles        [6]TileDef
19580                                 OverlayTiles [6]TileDef
19581                                 //mt:const uint8(6)
19582                                 SpecialTiles [6]TileDef
19583
19584                                 Color   color.NRGBA
19585                                 Palette Texture
19586
19587                                 Waving       WaveType
19588                                 ConnectSides uint8
19589                                 ConnectTo    []Content
19590                                 InsideTint   color.NRGBA
19591                                 Level        uint8 // Must be < 128.
19592
19593                                 Translucent bool // Sunlight is scattered and becomes normal light.
19594                                 Transparent bool // Sunlight isn't scattered.
19595                                 LightSrc    uint8
19596
19597                                 GndContent   bool
19598                                 Collides     bool
19599                                 Pointable    bool
19600                                 Diggable     bool
19601                                 Climbable    bool
19602                                 Replaceable  bool
19603                                 OnRightClick bool
19604
19605                                 DmgPerSec int32
19606
19607                                 LiquidType   LiquidType
19608                                 FlowingAlt   string
19609                                 SrcAlt       string
19610                                 Viscosity    uint8 // 0-7
19611                                 LiqRenewable bool
19612                                 FlowRange    uint8
19613                                 DrownDmg     uint8
19614                                 Floodable    bool
19615
19616                                 DrawBox, ColBox, SelBox NodeBox
19617
19618                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19619
19620                                 LegacyFaceDir bool
19621                                 LegacyMounted bool
19622
19623                                 DigPredict string
19624
19625                                 MaxLvl uint8
19626
19627                                 AlphaUse
19628
19629                                 MoveResistance uint8
19630
19631                                 LiquidMovePhysics bool
19632                         }))(obj)).P1Type).deserialize(r)
19633                 }); err != nil {
19634                         if err == io.EOF {
19635                                 chk(io.EOF)
19636                         }
19637                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param1Type", err))
19638                 }
19639                 if err := pcall(func() {
19640                         ((*(*(struct {
19641                                 Param0 Content
19642
19643                                 Name   string
19644                                 Groups []Group
19645
19646                                 P1Type   Param1Type
19647                                 P2Type   Param2Type
19648                                 DrawType DrawType
19649
19650                                 Mesh  string
19651                                 Scale float32
19652                                 //mt:const uint8(6)
19653                                 Tiles        [6]TileDef
19654                                 OverlayTiles [6]TileDef
19655                                 //mt:const uint8(6)
19656                                 SpecialTiles [6]TileDef
19657
19658                                 Color   color.NRGBA
19659                                 Palette Texture
19660
19661                                 Waving       WaveType
19662                                 ConnectSides uint8
19663                                 ConnectTo    []Content
19664                                 InsideTint   color.NRGBA
19665                                 Level        uint8 // Must be < 128.
19666
19667                                 Translucent bool // Sunlight is scattered and becomes normal light.
19668                                 Transparent bool // Sunlight isn't scattered.
19669                                 LightSrc    uint8
19670
19671                                 GndContent   bool
19672                                 Collides     bool
19673                                 Pointable    bool
19674                                 Diggable     bool
19675                                 Climbable    bool
19676                                 Replaceable  bool
19677                                 OnRightClick bool
19678
19679                                 DmgPerSec int32
19680
19681                                 LiquidType   LiquidType
19682                                 FlowingAlt   string
19683                                 SrcAlt       string
19684                                 Viscosity    uint8 // 0-7
19685                                 LiqRenewable bool
19686                                 FlowRange    uint8
19687                                 DrownDmg     uint8
19688                                 Floodable    bool
19689
19690                                 DrawBox, ColBox, SelBox NodeBox
19691
19692                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19693
19694                                 LegacyFaceDir bool
19695                                 LegacyMounted bool
19696
19697                                 DigPredict string
19698
19699                                 MaxLvl uint8
19700
19701                                 AlphaUse
19702
19703                                 MoveResistance uint8
19704
19705                                 LiquidMovePhysics bool
19706                         }))(obj)).P2Type).deserialize(r)
19707                 }); err != nil {
19708                         if err == io.EOF {
19709                                 chk(io.EOF)
19710                         }
19711                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param2Type", err))
19712                 }
19713                 if err := pcall(func() {
19714                         ((*(*(struct {
19715                                 Param0 Content
19716
19717                                 Name   string
19718                                 Groups []Group
19719
19720                                 P1Type   Param1Type
19721                                 P2Type   Param2Type
19722                                 DrawType DrawType
19723
19724                                 Mesh  string
19725                                 Scale float32
19726                                 //mt:const uint8(6)
19727                                 Tiles        [6]TileDef
19728                                 OverlayTiles [6]TileDef
19729                                 //mt:const uint8(6)
19730                                 SpecialTiles [6]TileDef
19731
19732                                 Color   color.NRGBA
19733                                 Palette Texture
19734
19735                                 Waving       WaveType
19736                                 ConnectSides uint8
19737                                 ConnectTo    []Content
19738                                 InsideTint   color.NRGBA
19739                                 Level        uint8 // Must be < 128.
19740
19741                                 Translucent bool // Sunlight is scattered and becomes normal light.
19742                                 Transparent bool // Sunlight isn't scattered.
19743                                 LightSrc    uint8
19744
19745                                 GndContent   bool
19746                                 Collides     bool
19747                                 Pointable    bool
19748                                 Diggable     bool
19749                                 Climbable    bool
19750                                 Replaceable  bool
19751                                 OnRightClick bool
19752
19753                                 DmgPerSec int32
19754
19755                                 LiquidType   LiquidType
19756                                 FlowingAlt   string
19757                                 SrcAlt       string
19758                                 Viscosity    uint8 // 0-7
19759                                 LiqRenewable bool
19760                                 FlowRange    uint8
19761                                 DrownDmg     uint8
19762                                 Floodable    bool
19763
19764                                 DrawBox, ColBox, SelBox NodeBox
19765
19766                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19767
19768                                 LegacyFaceDir bool
19769                                 LegacyMounted bool
19770
19771                                 DigPredict string
19772
19773                                 MaxLvl uint8
19774
19775                                 AlphaUse
19776
19777                                 MoveResistance uint8
19778
19779                                 LiquidMovePhysics bool
19780                         }))(obj)).DrawType).deserialize(r)
19781                 }); err != nil {
19782                         if err == io.EOF {
19783                                 chk(io.EOF)
19784                         }
19785                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DrawType", err))
19786                 }
19787                 var local252 []uint8
19788                 var local253 uint16
19789                 {
19790                         p := &local253
19791                         *p = read16(r)
19792                 }
19793                 (local252) = make([]uint8, local253)
19794                 {
19795                         _, err := io.ReadFull(r, (local252)[:])
19796                         chk(err)
19797                 }
19798                 ((*(*(struct {
19799                         Param0 Content
19800
19801                         Name   string
19802                         Groups []Group
19803
19804                         P1Type   Param1Type
19805                         P2Type   Param2Type
19806                         DrawType DrawType
19807
19808                         Mesh  string
19809                         Scale float32
19810                         //mt:const uint8(6)
19811                         Tiles        [6]TileDef
19812                         OverlayTiles [6]TileDef
19813                         //mt:const uint8(6)
19814                         SpecialTiles [6]TileDef
19815
19816                         Color   color.NRGBA
19817                         Palette Texture
19818
19819                         Waving       WaveType
19820                         ConnectSides uint8
19821                         ConnectTo    []Content
19822                         InsideTint   color.NRGBA
19823                         Level        uint8 // Must be < 128.
19824
19825                         Translucent bool // Sunlight is scattered and becomes normal light.
19826                         Transparent bool // Sunlight isn't scattered.
19827                         LightSrc    uint8
19828
19829                         GndContent   bool
19830                         Collides     bool
19831                         Pointable    bool
19832                         Diggable     bool
19833                         Climbable    bool
19834                         Replaceable  bool
19835                         OnRightClick bool
19836
19837                         DmgPerSec int32
19838
19839                         LiquidType   LiquidType
19840                         FlowingAlt   string
19841                         SrcAlt       string
19842                         Viscosity    uint8 // 0-7
19843                         LiqRenewable bool
19844                         FlowRange    uint8
19845                         DrownDmg     uint8
19846                         Floodable    bool
19847
19848                         DrawBox, ColBox, SelBox NodeBox
19849
19850                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19851
19852                         LegacyFaceDir bool
19853                         LegacyMounted bool
19854
19855                         DigPredict string
19856
19857                         MaxLvl uint8
19858
19859                         AlphaUse
19860
19861                         MoveResistance uint8
19862
19863                         LiquidMovePhysics bool
19864                 }))(obj)).Mesh) = string(local252)
19865                 {
19866                         p := &(*(*(struct {
19867                                 Param0 Content
19868
19869                                 Name   string
19870                                 Groups []Group
19871
19872                                 P1Type   Param1Type
19873                                 P2Type   Param2Type
19874                                 DrawType DrawType
19875
19876                                 Mesh  string
19877                                 Scale float32
19878                                 //mt:const uint8(6)
19879                                 Tiles        [6]TileDef
19880                                 OverlayTiles [6]TileDef
19881                                 //mt:const uint8(6)
19882                                 SpecialTiles [6]TileDef
19883
19884                                 Color   color.NRGBA
19885                                 Palette Texture
19886
19887                                 Waving       WaveType
19888                                 ConnectSides uint8
19889                                 ConnectTo    []Content
19890                                 InsideTint   color.NRGBA
19891                                 Level        uint8 // Must be < 128.
19892
19893                                 Translucent bool // Sunlight is scattered and becomes normal light.
19894                                 Transparent bool // Sunlight isn't scattered.
19895                                 LightSrc    uint8
19896
19897                                 GndContent   bool
19898                                 Collides     bool
19899                                 Pointable    bool
19900                                 Diggable     bool
19901                                 Climbable    bool
19902                                 Replaceable  bool
19903                                 OnRightClick bool
19904
19905                                 DmgPerSec int32
19906
19907                                 LiquidType   LiquidType
19908                                 FlowingAlt   string
19909                                 SrcAlt       string
19910                                 Viscosity    uint8 // 0-7
19911                                 LiqRenewable bool
19912                                 FlowRange    uint8
19913                                 DrownDmg     uint8
19914                                 Floodable    bool
19915
19916                                 DrawBox, ColBox, SelBox NodeBox
19917
19918                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19919
19920                                 LegacyFaceDir bool
19921                                 LegacyMounted bool
19922
19923                                 DigPredict string
19924
19925                                 MaxLvl uint8
19926
19927                                 AlphaUse
19928
19929                                 MoveResistance uint8
19930
19931                                 LiquidMovePhysics bool
19932                         }))(obj)).Scale
19933                         *p = math.Float32frombits(read32(r))
19934                 }
19935                 {
19936                         var local254 uint8
19937                         local255 := uint8(6)
19938                         {
19939                                 p := &local254
19940                                 *p = read8(r)
19941                         }
19942                         if local254 != local255 {
19943                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local254))
19944                         }
19945                 }
19946                 for local256 := range (*(*(struct {
19947                         Param0 Content
19948
19949                         Name   string
19950                         Groups []Group
19951
19952                         P1Type   Param1Type
19953                         P2Type   Param2Type
19954                         DrawType DrawType
19955
19956                         Mesh  string
19957                         Scale float32
19958                         //mt:const uint8(6)
19959                         Tiles        [6]TileDef
19960                         OverlayTiles [6]TileDef
19961                         //mt:const uint8(6)
19962                         SpecialTiles [6]TileDef
19963
19964                         Color   color.NRGBA
19965                         Palette Texture
19966
19967                         Waving       WaveType
19968                         ConnectSides uint8
19969                         ConnectTo    []Content
19970                         InsideTint   color.NRGBA
19971                         Level        uint8 // Must be < 128.
19972
19973                         Translucent bool // Sunlight is scattered and becomes normal light.
19974                         Transparent bool // Sunlight isn't scattered.
19975                         LightSrc    uint8
19976
19977                         GndContent   bool
19978                         Collides     bool
19979                         Pointable    bool
19980                         Diggable     bool
19981                         Climbable    bool
19982                         Replaceable  bool
19983                         OnRightClick bool
19984
19985                         DmgPerSec int32
19986
19987                         LiquidType   LiquidType
19988                         FlowingAlt   string
19989                         SrcAlt       string
19990                         Viscosity    uint8 // 0-7
19991                         LiqRenewable bool
19992                         FlowRange    uint8
19993                         DrownDmg     uint8
19994                         Floodable    bool
19995
19996                         DrawBox, ColBox, SelBox NodeBox
19997
19998                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19999
20000                         LegacyFaceDir bool
20001                         LegacyMounted bool
20002
20003                         DigPredict string
20004
20005                         MaxLvl uint8
20006
20007                         AlphaUse
20008
20009                         MoveResistance uint8
20010
20011                         LiquidMovePhysics bool
20012                 }))(obj)).Tiles {
20013                         if err := pcall(func() {
20014                                 (((*(*(struct {
20015                                         Param0 Content
20016
20017                                         Name   string
20018                                         Groups []Group
20019
20020                                         P1Type   Param1Type
20021                                         P2Type   Param2Type
20022                                         DrawType DrawType
20023
20024                                         Mesh  string
20025                                         Scale float32
20026                                         //mt:const uint8(6)
20027                                         Tiles        [6]TileDef
20028                                         OverlayTiles [6]TileDef
20029                                         //mt:const uint8(6)
20030                                         SpecialTiles [6]TileDef
20031
20032                                         Color   color.NRGBA
20033                                         Palette Texture
20034
20035                                         Waving       WaveType
20036                                         ConnectSides uint8
20037                                         ConnectTo    []Content
20038                                         InsideTint   color.NRGBA
20039                                         Level        uint8 // Must be < 128.
20040
20041                                         Translucent bool // Sunlight is scattered and becomes normal light.
20042                                         Transparent bool // Sunlight isn't scattered.
20043                                         LightSrc    uint8
20044
20045                                         GndContent   bool
20046                                         Collides     bool
20047                                         Pointable    bool
20048                                         Diggable     bool
20049                                         Climbable    bool
20050                                         Replaceable  bool
20051                                         OnRightClick bool
20052
20053                                         DmgPerSec int32
20054
20055                                         LiquidType   LiquidType
20056                                         FlowingAlt   string
20057                                         SrcAlt       string
20058                                         Viscosity    uint8 // 0-7
20059                                         LiqRenewable bool
20060                                         FlowRange    uint8
20061                                         DrownDmg     uint8
20062                                         Floodable    bool
20063
20064                                         DrawBox, ColBox, SelBox NodeBox
20065
20066                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20067
20068                                         LegacyFaceDir bool
20069                                         LegacyMounted bool
20070
20071                                         DigPredict string
20072
20073                                         MaxLvl uint8
20074
20075                                         AlphaUse
20076
20077                                         MoveResistance uint8
20078
20079                                         LiquidMovePhysics bool
20080                                 }))(obj)).Tiles)[local256]).deserialize(r)
20081                         }); err != nil {
20082                                 if err == io.EOF {
20083                                         chk(io.EOF)
20084                                 }
20085                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20086                         }
20087                 }
20088                 for local257 := range (*(*(struct {
20089                         Param0 Content
20090
20091                         Name   string
20092                         Groups []Group
20093
20094                         P1Type   Param1Type
20095                         P2Type   Param2Type
20096                         DrawType DrawType
20097
20098                         Mesh  string
20099                         Scale float32
20100                         //mt:const uint8(6)
20101                         Tiles        [6]TileDef
20102                         OverlayTiles [6]TileDef
20103                         //mt:const uint8(6)
20104                         SpecialTiles [6]TileDef
20105
20106                         Color   color.NRGBA
20107                         Palette Texture
20108
20109                         Waving       WaveType
20110                         ConnectSides uint8
20111                         ConnectTo    []Content
20112                         InsideTint   color.NRGBA
20113                         Level        uint8 // Must be < 128.
20114
20115                         Translucent bool // Sunlight is scattered and becomes normal light.
20116                         Transparent bool // Sunlight isn't scattered.
20117                         LightSrc    uint8
20118
20119                         GndContent   bool
20120                         Collides     bool
20121                         Pointable    bool
20122                         Diggable     bool
20123                         Climbable    bool
20124                         Replaceable  bool
20125                         OnRightClick bool
20126
20127                         DmgPerSec int32
20128
20129                         LiquidType   LiquidType
20130                         FlowingAlt   string
20131                         SrcAlt       string
20132                         Viscosity    uint8 // 0-7
20133                         LiqRenewable bool
20134                         FlowRange    uint8
20135                         DrownDmg     uint8
20136                         Floodable    bool
20137
20138                         DrawBox, ColBox, SelBox NodeBox
20139
20140                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20141
20142                         LegacyFaceDir bool
20143                         LegacyMounted bool
20144
20145                         DigPredict string
20146
20147                         MaxLvl uint8
20148
20149                         AlphaUse
20150
20151                         MoveResistance uint8
20152
20153                         LiquidMovePhysics bool
20154                 }))(obj)).OverlayTiles {
20155                         if err := pcall(func() {
20156                                 (((*(*(struct {
20157                                         Param0 Content
20158
20159                                         Name   string
20160                                         Groups []Group
20161
20162                                         P1Type   Param1Type
20163                                         P2Type   Param2Type
20164                                         DrawType DrawType
20165
20166                                         Mesh  string
20167                                         Scale float32
20168                                         //mt:const uint8(6)
20169                                         Tiles        [6]TileDef
20170                                         OverlayTiles [6]TileDef
20171                                         //mt:const uint8(6)
20172                                         SpecialTiles [6]TileDef
20173
20174                                         Color   color.NRGBA
20175                                         Palette Texture
20176
20177                                         Waving       WaveType
20178                                         ConnectSides uint8
20179                                         ConnectTo    []Content
20180                                         InsideTint   color.NRGBA
20181                                         Level        uint8 // Must be < 128.
20182
20183                                         Translucent bool // Sunlight is scattered and becomes normal light.
20184                                         Transparent bool // Sunlight isn't scattered.
20185                                         LightSrc    uint8
20186
20187                                         GndContent   bool
20188                                         Collides     bool
20189                                         Pointable    bool
20190                                         Diggable     bool
20191                                         Climbable    bool
20192                                         Replaceable  bool
20193                                         OnRightClick bool
20194
20195                                         DmgPerSec int32
20196
20197                                         LiquidType   LiquidType
20198                                         FlowingAlt   string
20199                                         SrcAlt       string
20200                                         Viscosity    uint8 // 0-7
20201                                         LiqRenewable bool
20202                                         FlowRange    uint8
20203                                         DrownDmg     uint8
20204                                         Floodable    bool
20205
20206                                         DrawBox, ColBox, SelBox NodeBox
20207
20208                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20209
20210                                         LegacyFaceDir bool
20211                                         LegacyMounted bool
20212
20213                                         DigPredict string
20214
20215                                         MaxLvl uint8
20216
20217                                         AlphaUse
20218
20219                                         MoveResistance uint8
20220
20221                                         LiquidMovePhysics bool
20222                                 }))(obj)).OverlayTiles)[local257]).deserialize(r)
20223                         }); err != nil {
20224                                 if err == io.EOF {
20225                                         chk(io.EOF)
20226                                 }
20227                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20228                         }
20229                 }
20230                 {
20231                         var local258 uint8
20232                         local259 := uint8(6)
20233                         {
20234                                 p := &local258
20235                                 *p = read8(r)
20236                         }
20237                         if local258 != local259 {
20238                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local258))
20239                         }
20240                 }
20241                 for local260 := range (*(*(struct {
20242                         Param0 Content
20243
20244                         Name   string
20245                         Groups []Group
20246
20247                         P1Type   Param1Type
20248                         P2Type   Param2Type
20249                         DrawType DrawType
20250
20251                         Mesh  string
20252                         Scale float32
20253                         //mt:const uint8(6)
20254                         Tiles        [6]TileDef
20255                         OverlayTiles [6]TileDef
20256                         //mt:const uint8(6)
20257                         SpecialTiles [6]TileDef
20258
20259                         Color   color.NRGBA
20260                         Palette Texture
20261
20262                         Waving       WaveType
20263                         ConnectSides uint8
20264                         ConnectTo    []Content
20265                         InsideTint   color.NRGBA
20266                         Level        uint8 // Must be < 128.
20267
20268                         Translucent bool // Sunlight is scattered and becomes normal light.
20269                         Transparent bool // Sunlight isn't scattered.
20270                         LightSrc    uint8
20271
20272                         GndContent   bool
20273                         Collides     bool
20274                         Pointable    bool
20275                         Diggable     bool
20276                         Climbable    bool
20277                         Replaceable  bool
20278                         OnRightClick bool
20279
20280                         DmgPerSec int32
20281
20282                         LiquidType   LiquidType
20283                         FlowingAlt   string
20284                         SrcAlt       string
20285                         Viscosity    uint8 // 0-7
20286                         LiqRenewable bool
20287                         FlowRange    uint8
20288                         DrownDmg     uint8
20289                         Floodable    bool
20290
20291                         DrawBox, ColBox, SelBox NodeBox
20292
20293                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20294
20295                         LegacyFaceDir bool
20296                         LegacyMounted bool
20297
20298                         DigPredict string
20299
20300                         MaxLvl uint8
20301
20302                         AlphaUse
20303
20304                         MoveResistance uint8
20305
20306                         LiquidMovePhysics bool
20307                 }))(obj)).SpecialTiles {
20308                         if err := pcall(func() {
20309                                 (((*(*(struct {
20310                                         Param0 Content
20311
20312                                         Name   string
20313                                         Groups []Group
20314
20315                                         P1Type   Param1Type
20316                                         P2Type   Param2Type
20317                                         DrawType DrawType
20318
20319                                         Mesh  string
20320                                         Scale float32
20321                                         //mt:const uint8(6)
20322                                         Tiles        [6]TileDef
20323                                         OverlayTiles [6]TileDef
20324                                         //mt:const uint8(6)
20325                                         SpecialTiles [6]TileDef
20326
20327                                         Color   color.NRGBA
20328                                         Palette Texture
20329
20330                                         Waving       WaveType
20331                                         ConnectSides uint8
20332                                         ConnectTo    []Content
20333                                         InsideTint   color.NRGBA
20334                                         Level        uint8 // Must be < 128.
20335
20336                                         Translucent bool // Sunlight is scattered and becomes normal light.
20337                                         Transparent bool // Sunlight isn't scattered.
20338                                         LightSrc    uint8
20339
20340                                         GndContent   bool
20341                                         Collides     bool
20342                                         Pointable    bool
20343                                         Diggable     bool
20344                                         Climbable    bool
20345                                         Replaceable  bool
20346                                         OnRightClick bool
20347
20348                                         DmgPerSec int32
20349
20350                                         LiquidType   LiquidType
20351                                         FlowingAlt   string
20352                                         SrcAlt       string
20353                                         Viscosity    uint8 // 0-7
20354                                         LiqRenewable bool
20355                                         FlowRange    uint8
20356                                         DrownDmg     uint8
20357                                         Floodable    bool
20358
20359                                         DrawBox, ColBox, SelBox NodeBox
20360
20361                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20362
20363                                         LegacyFaceDir bool
20364                                         LegacyMounted bool
20365
20366                                         DigPredict string
20367
20368                                         MaxLvl uint8
20369
20370                                         AlphaUse
20371
20372                                         MoveResistance uint8
20373
20374                                         LiquidMovePhysics bool
20375                                 }))(obj)).SpecialTiles)[local260]).deserialize(r)
20376                         }); err != nil {
20377                                 if err == io.EOF {
20378                                         chk(io.EOF)
20379                                 }
20380                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20381                         }
20382                 }
20383                 {
20384                         p := &(*(*(struct {
20385                                 Param0 Content
20386
20387                                 Name   string
20388                                 Groups []Group
20389
20390                                 P1Type   Param1Type
20391                                 P2Type   Param2Type
20392                                 DrawType DrawType
20393
20394                                 Mesh  string
20395                                 Scale float32
20396                                 //mt:const uint8(6)
20397                                 Tiles        [6]TileDef
20398                                 OverlayTiles [6]TileDef
20399                                 //mt:const uint8(6)
20400                                 SpecialTiles [6]TileDef
20401
20402                                 Color   color.NRGBA
20403                                 Palette Texture
20404
20405                                 Waving       WaveType
20406                                 ConnectSides uint8
20407                                 ConnectTo    []Content
20408                                 InsideTint   color.NRGBA
20409                                 Level        uint8 // Must be < 128.
20410
20411                                 Translucent bool // Sunlight is scattered and becomes normal light.
20412                                 Transparent bool // Sunlight isn't scattered.
20413                                 LightSrc    uint8
20414
20415                                 GndContent   bool
20416                                 Collides     bool
20417                                 Pointable    bool
20418                                 Diggable     bool
20419                                 Climbable    bool
20420                                 Replaceable  bool
20421                                 OnRightClick bool
20422
20423                                 DmgPerSec int32
20424
20425                                 LiquidType   LiquidType
20426                                 FlowingAlt   string
20427                                 SrcAlt       string
20428                                 Viscosity    uint8 // 0-7
20429                                 LiqRenewable bool
20430                                 FlowRange    uint8
20431                                 DrownDmg     uint8
20432                                 Floodable    bool
20433
20434                                 DrawBox, ColBox, SelBox NodeBox
20435
20436                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20437
20438                                 LegacyFaceDir bool
20439                                 LegacyMounted bool
20440
20441                                 DigPredict string
20442
20443                                 MaxLvl uint8
20444
20445                                 AlphaUse
20446
20447                                 MoveResistance uint8
20448
20449                                 LiquidMovePhysics bool
20450                         }))(obj)).Color
20451                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20452                 }
20453                 if err := pcall(func() {
20454                         ((*(*(struct {
20455                                 Param0 Content
20456
20457                                 Name   string
20458                                 Groups []Group
20459
20460                                 P1Type   Param1Type
20461                                 P2Type   Param2Type
20462                                 DrawType DrawType
20463
20464                                 Mesh  string
20465                                 Scale float32
20466                                 //mt:const uint8(6)
20467                                 Tiles        [6]TileDef
20468                                 OverlayTiles [6]TileDef
20469                                 //mt:const uint8(6)
20470                                 SpecialTiles [6]TileDef
20471
20472                                 Color   color.NRGBA
20473                                 Palette Texture
20474
20475                                 Waving       WaveType
20476                                 ConnectSides uint8
20477                                 ConnectTo    []Content
20478                                 InsideTint   color.NRGBA
20479                                 Level        uint8 // Must be < 128.
20480
20481                                 Translucent bool // Sunlight is scattered and becomes normal light.
20482                                 Transparent bool // Sunlight isn't scattered.
20483                                 LightSrc    uint8
20484
20485                                 GndContent   bool
20486                                 Collides     bool
20487                                 Pointable    bool
20488                                 Diggable     bool
20489                                 Climbable    bool
20490                                 Replaceable  bool
20491                                 OnRightClick bool
20492
20493                                 DmgPerSec int32
20494
20495                                 LiquidType   LiquidType
20496                                 FlowingAlt   string
20497                                 SrcAlt       string
20498                                 Viscosity    uint8 // 0-7
20499                                 LiqRenewable bool
20500                                 FlowRange    uint8
20501                                 DrownDmg     uint8
20502                                 Floodable    bool
20503
20504                                 DrawBox, ColBox, SelBox NodeBox
20505
20506                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20507
20508                                 LegacyFaceDir bool
20509                                 LegacyMounted bool
20510
20511                                 DigPredict string
20512
20513                                 MaxLvl uint8
20514
20515                                 AlphaUse
20516
20517                                 MoveResistance uint8
20518
20519                                 LiquidMovePhysics bool
20520                         }))(obj)).Palette).deserialize(r)
20521                 }); err != nil {
20522                         if err == io.EOF {
20523                                 chk(io.EOF)
20524                         }
20525                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
20526                 }
20527                 if err := pcall(func() {
20528                         ((*(*(struct {
20529                                 Param0 Content
20530
20531                                 Name   string
20532                                 Groups []Group
20533
20534                                 P1Type   Param1Type
20535                                 P2Type   Param2Type
20536                                 DrawType DrawType
20537
20538                                 Mesh  string
20539                                 Scale float32
20540                                 //mt:const uint8(6)
20541                                 Tiles        [6]TileDef
20542                                 OverlayTiles [6]TileDef
20543                                 //mt:const uint8(6)
20544                                 SpecialTiles [6]TileDef
20545
20546                                 Color   color.NRGBA
20547                                 Palette Texture
20548
20549                                 Waving       WaveType
20550                                 ConnectSides uint8
20551                                 ConnectTo    []Content
20552                                 InsideTint   color.NRGBA
20553                                 Level        uint8 // Must be < 128.
20554
20555                                 Translucent bool // Sunlight is scattered and becomes normal light.
20556                                 Transparent bool // Sunlight isn't scattered.
20557                                 LightSrc    uint8
20558
20559                                 GndContent   bool
20560                                 Collides     bool
20561                                 Pointable    bool
20562                                 Diggable     bool
20563                                 Climbable    bool
20564                                 Replaceable  bool
20565                                 OnRightClick bool
20566
20567                                 DmgPerSec int32
20568
20569                                 LiquidType   LiquidType
20570                                 FlowingAlt   string
20571                                 SrcAlt       string
20572                                 Viscosity    uint8 // 0-7
20573                                 LiqRenewable bool
20574                                 FlowRange    uint8
20575                                 DrownDmg     uint8
20576                                 Floodable    bool
20577
20578                                 DrawBox, ColBox, SelBox NodeBox
20579
20580                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20581
20582                                 LegacyFaceDir bool
20583                                 LegacyMounted bool
20584
20585                                 DigPredict string
20586
20587                                 MaxLvl uint8
20588
20589                                 AlphaUse
20590
20591                                 MoveResistance uint8
20592
20593                                 LiquidMovePhysics bool
20594                         }))(obj)).Waving).deserialize(r)
20595                 }); err != nil {
20596                         if err == io.EOF {
20597                                 chk(io.EOF)
20598                         }
20599                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.WaveType", err))
20600                 }
20601                 {
20602                         p := &(*(*(struct {
20603                                 Param0 Content
20604
20605                                 Name   string
20606                                 Groups []Group
20607
20608                                 P1Type   Param1Type
20609                                 P2Type   Param2Type
20610                                 DrawType DrawType
20611
20612                                 Mesh  string
20613                                 Scale float32
20614                                 //mt:const uint8(6)
20615                                 Tiles        [6]TileDef
20616                                 OverlayTiles [6]TileDef
20617                                 //mt:const uint8(6)
20618                                 SpecialTiles [6]TileDef
20619
20620                                 Color   color.NRGBA
20621                                 Palette Texture
20622
20623                                 Waving       WaveType
20624                                 ConnectSides uint8
20625                                 ConnectTo    []Content
20626                                 InsideTint   color.NRGBA
20627                                 Level        uint8 // Must be < 128.
20628
20629                                 Translucent bool // Sunlight is scattered and becomes normal light.
20630                                 Transparent bool // Sunlight isn't scattered.
20631                                 LightSrc    uint8
20632
20633                                 GndContent   bool
20634                                 Collides     bool
20635                                 Pointable    bool
20636                                 Diggable     bool
20637                                 Climbable    bool
20638                                 Replaceable  bool
20639                                 OnRightClick bool
20640
20641                                 DmgPerSec int32
20642
20643                                 LiquidType   LiquidType
20644                                 FlowingAlt   string
20645                                 SrcAlt       string
20646                                 Viscosity    uint8 // 0-7
20647                                 LiqRenewable bool
20648                                 FlowRange    uint8
20649                                 DrownDmg     uint8
20650                                 Floodable    bool
20651
20652                                 DrawBox, ColBox, SelBox NodeBox
20653
20654                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20655
20656                                 LegacyFaceDir bool
20657                                 LegacyMounted bool
20658
20659                                 DigPredict string
20660
20661                                 MaxLvl uint8
20662
20663                                 AlphaUse
20664
20665                                 MoveResistance uint8
20666
20667                                 LiquidMovePhysics bool
20668                         }))(obj)).ConnectSides
20669                         *p = read8(r)
20670                 }
20671                 var local261 uint16
20672                 {
20673                         p := &local261
20674                         *p = read16(r)
20675                 }
20676                 ((*(*(struct {
20677                         Param0 Content
20678
20679                         Name   string
20680                         Groups []Group
20681
20682                         P1Type   Param1Type
20683                         P2Type   Param2Type
20684                         DrawType DrawType
20685
20686                         Mesh  string
20687                         Scale float32
20688                         //mt:const uint8(6)
20689                         Tiles        [6]TileDef
20690                         OverlayTiles [6]TileDef
20691                         //mt:const uint8(6)
20692                         SpecialTiles [6]TileDef
20693
20694                         Color   color.NRGBA
20695                         Palette Texture
20696
20697                         Waving       WaveType
20698                         ConnectSides uint8
20699                         ConnectTo    []Content
20700                         InsideTint   color.NRGBA
20701                         Level        uint8 // Must be < 128.
20702
20703                         Translucent bool // Sunlight is scattered and becomes normal light.
20704                         Transparent bool // Sunlight isn't scattered.
20705                         LightSrc    uint8
20706
20707                         GndContent   bool
20708                         Collides     bool
20709                         Pointable    bool
20710                         Diggable     bool
20711                         Climbable    bool
20712                         Replaceable  bool
20713                         OnRightClick bool
20714
20715                         DmgPerSec int32
20716
20717                         LiquidType   LiquidType
20718                         FlowingAlt   string
20719                         SrcAlt       string
20720                         Viscosity    uint8 // 0-7
20721                         LiqRenewable bool
20722                         FlowRange    uint8
20723                         DrownDmg     uint8
20724                         Floodable    bool
20725
20726                         DrawBox, ColBox, SelBox NodeBox
20727
20728                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20729
20730                         LegacyFaceDir bool
20731                         LegacyMounted bool
20732
20733                         DigPredict string
20734
20735                         MaxLvl uint8
20736
20737                         AlphaUse
20738
20739                         MoveResistance uint8
20740
20741                         LiquidMovePhysics bool
20742                 }))(obj)).ConnectTo) = make([]Content, local261)
20743                 for local262 := range (*(*(struct {
20744                         Param0 Content
20745
20746                         Name   string
20747                         Groups []Group
20748
20749                         P1Type   Param1Type
20750                         P2Type   Param2Type
20751                         DrawType DrawType
20752
20753                         Mesh  string
20754                         Scale float32
20755                         //mt:const uint8(6)
20756                         Tiles        [6]TileDef
20757                         OverlayTiles [6]TileDef
20758                         //mt:const uint8(6)
20759                         SpecialTiles [6]TileDef
20760
20761                         Color   color.NRGBA
20762                         Palette Texture
20763
20764                         Waving       WaveType
20765                         ConnectSides uint8
20766                         ConnectTo    []Content
20767                         InsideTint   color.NRGBA
20768                         Level        uint8 // Must be < 128.
20769
20770                         Translucent bool // Sunlight is scattered and becomes normal light.
20771                         Transparent bool // Sunlight isn't scattered.
20772                         LightSrc    uint8
20773
20774                         GndContent   bool
20775                         Collides     bool
20776                         Pointable    bool
20777                         Diggable     bool
20778                         Climbable    bool
20779                         Replaceable  bool
20780                         OnRightClick bool
20781
20782                         DmgPerSec int32
20783
20784                         LiquidType   LiquidType
20785                         FlowingAlt   string
20786                         SrcAlt       string
20787                         Viscosity    uint8 // 0-7
20788                         LiqRenewable bool
20789                         FlowRange    uint8
20790                         DrownDmg     uint8
20791                         Floodable    bool
20792
20793                         DrawBox, ColBox, SelBox NodeBox
20794
20795                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20796
20797                         LegacyFaceDir bool
20798                         LegacyMounted bool
20799
20800                         DigPredict string
20801
20802                         MaxLvl uint8
20803
20804                         AlphaUse
20805
20806                         MoveResistance uint8
20807
20808                         LiquidMovePhysics bool
20809                 }))(obj)).ConnectTo {
20810                         if err := pcall(func() {
20811                                 (((*(*(struct {
20812                                         Param0 Content
20813
20814                                         Name   string
20815                                         Groups []Group
20816
20817                                         P1Type   Param1Type
20818                                         P2Type   Param2Type
20819                                         DrawType DrawType
20820
20821                                         Mesh  string
20822                                         Scale float32
20823                                         //mt:const uint8(6)
20824                                         Tiles        [6]TileDef
20825                                         OverlayTiles [6]TileDef
20826                                         //mt:const uint8(6)
20827                                         SpecialTiles [6]TileDef
20828
20829                                         Color   color.NRGBA
20830                                         Palette Texture
20831
20832                                         Waving       WaveType
20833                                         ConnectSides uint8
20834                                         ConnectTo    []Content
20835                                         InsideTint   color.NRGBA
20836                                         Level        uint8 // Must be < 128.
20837
20838                                         Translucent bool // Sunlight is scattered and becomes normal light.
20839                                         Transparent bool // Sunlight isn't scattered.
20840                                         LightSrc    uint8
20841
20842                                         GndContent   bool
20843                                         Collides     bool
20844                                         Pointable    bool
20845                                         Diggable     bool
20846                                         Climbable    bool
20847                                         Replaceable  bool
20848                                         OnRightClick bool
20849
20850                                         DmgPerSec int32
20851
20852                                         LiquidType   LiquidType
20853                                         FlowingAlt   string
20854                                         SrcAlt       string
20855                                         Viscosity    uint8 // 0-7
20856                                         LiqRenewable bool
20857                                         FlowRange    uint8
20858                                         DrownDmg     uint8
20859                                         Floodable    bool
20860
20861                                         DrawBox, ColBox, SelBox NodeBox
20862
20863                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20864
20865                                         LegacyFaceDir bool
20866                                         LegacyMounted bool
20867
20868                                         DigPredict string
20869
20870                                         MaxLvl uint8
20871
20872                                         AlphaUse
20873
20874                                         MoveResistance uint8
20875
20876                                         LiquidMovePhysics bool
20877                                 }))(obj)).ConnectTo)[local262]).deserialize(r)
20878                         }); err != nil {
20879                                 if err == io.EOF {
20880                                         chk(io.EOF)
20881                                 }
20882                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
20883                         }
20884                 }
20885                 {
20886                         p := &(*(*(struct {
20887                                 Param0 Content
20888
20889                                 Name   string
20890                                 Groups []Group
20891
20892                                 P1Type   Param1Type
20893                                 P2Type   Param2Type
20894                                 DrawType DrawType
20895
20896                                 Mesh  string
20897                                 Scale float32
20898                                 //mt:const uint8(6)
20899                                 Tiles        [6]TileDef
20900                                 OverlayTiles [6]TileDef
20901                                 //mt:const uint8(6)
20902                                 SpecialTiles [6]TileDef
20903
20904                                 Color   color.NRGBA
20905                                 Palette Texture
20906
20907                                 Waving       WaveType
20908                                 ConnectSides uint8
20909                                 ConnectTo    []Content
20910                                 InsideTint   color.NRGBA
20911                                 Level        uint8 // Must be < 128.
20912
20913                                 Translucent bool // Sunlight is scattered and becomes normal light.
20914                                 Transparent bool // Sunlight isn't scattered.
20915                                 LightSrc    uint8
20916
20917                                 GndContent   bool
20918                                 Collides     bool
20919                                 Pointable    bool
20920                                 Diggable     bool
20921                                 Climbable    bool
20922                                 Replaceable  bool
20923                                 OnRightClick bool
20924
20925                                 DmgPerSec int32
20926
20927                                 LiquidType   LiquidType
20928                                 FlowingAlt   string
20929                                 SrcAlt       string
20930                                 Viscosity    uint8 // 0-7
20931                                 LiqRenewable bool
20932                                 FlowRange    uint8
20933                                 DrownDmg     uint8
20934                                 Floodable    bool
20935
20936                                 DrawBox, ColBox, SelBox NodeBox
20937
20938                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20939
20940                                 LegacyFaceDir bool
20941                                 LegacyMounted bool
20942
20943                                 DigPredict string
20944
20945                                 MaxLvl uint8
20946
20947                                 AlphaUse
20948
20949                                 MoveResistance uint8
20950
20951                                 LiquidMovePhysics bool
20952                         }))(obj)).InsideTint
20953                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20954                 }
20955                 {
20956                         p := &(*(*(struct {
20957                                 Param0 Content
20958
20959                                 Name   string
20960                                 Groups []Group
20961
20962                                 P1Type   Param1Type
20963                                 P2Type   Param2Type
20964                                 DrawType DrawType
20965
20966                                 Mesh  string
20967                                 Scale float32
20968                                 //mt:const uint8(6)
20969                                 Tiles        [6]TileDef
20970                                 OverlayTiles [6]TileDef
20971                                 //mt:const uint8(6)
20972                                 SpecialTiles [6]TileDef
20973
20974                                 Color   color.NRGBA
20975                                 Palette Texture
20976
20977                                 Waving       WaveType
20978                                 ConnectSides uint8
20979                                 ConnectTo    []Content
20980                                 InsideTint   color.NRGBA
20981                                 Level        uint8 // Must be < 128.
20982
20983                                 Translucent bool // Sunlight is scattered and becomes normal light.
20984                                 Transparent bool // Sunlight isn't scattered.
20985                                 LightSrc    uint8
20986
20987                                 GndContent   bool
20988                                 Collides     bool
20989                                 Pointable    bool
20990                                 Diggable     bool
20991                                 Climbable    bool
20992                                 Replaceable  bool
20993                                 OnRightClick bool
20994
20995                                 DmgPerSec int32
20996
20997                                 LiquidType   LiquidType
20998                                 FlowingAlt   string
20999                                 SrcAlt       string
21000                                 Viscosity    uint8 // 0-7
21001                                 LiqRenewable bool
21002                                 FlowRange    uint8
21003                                 DrownDmg     uint8
21004                                 Floodable    bool
21005
21006                                 DrawBox, ColBox, SelBox NodeBox
21007
21008                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21009
21010                                 LegacyFaceDir bool
21011                                 LegacyMounted bool
21012
21013                                 DigPredict string
21014
21015                                 MaxLvl uint8
21016
21017                                 AlphaUse
21018
21019                                 MoveResistance uint8
21020
21021                                 LiquidMovePhysics bool
21022                         }))(obj)).Level
21023                         *p = read8(r)
21024                 }
21025                 {
21026                         p := &(*(*(struct {
21027                                 Param0 Content
21028
21029                                 Name   string
21030                                 Groups []Group
21031
21032                                 P1Type   Param1Type
21033                                 P2Type   Param2Type
21034                                 DrawType DrawType
21035
21036                                 Mesh  string
21037                                 Scale float32
21038                                 //mt:const uint8(6)
21039                                 Tiles        [6]TileDef
21040                                 OverlayTiles [6]TileDef
21041                                 //mt:const uint8(6)
21042                                 SpecialTiles [6]TileDef
21043
21044                                 Color   color.NRGBA
21045                                 Palette Texture
21046
21047                                 Waving       WaveType
21048                                 ConnectSides uint8
21049                                 ConnectTo    []Content
21050                                 InsideTint   color.NRGBA
21051                                 Level        uint8 // Must be < 128.
21052
21053                                 Translucent bool // Sunlight is scattered and becomes normal light.
21054                                 Transparent bool // Sunlight isn't scattered.
21055                                 LightSrc    uint8
21056
21057                                 GndContent   bool
21058                                 Collides     bool
21059                                 Pointable    bool
21060                                 Diggable     bool
21061                                 Climbable    bool
21062                                 Replaceable  bool
21063                                 OnRightClick bool
21064
21065                                 DmgPerSec int32
21066
21067                                 LiquidType   LiquidType
21068                                 FlowingAlt   string
21069                                 SrcAlt       string
21070                                 Viscosity    uint8 // 0-7
21071                                 LiqRenewable bool
21072                                 FlowRange    uint8
21073                                 DrownDmg     uint8
21074                                 Floodable    bool
21075
21076                                 DrawBox, ColBox, SelBox NodeBox
21077
21078                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21079
21080                                 LegacyFaceDir bool
21081                                 LegacyMounted bool
21082
21083                                 DigPredict string
21084
21085                                 MaxLvl uint8
21086
21087                                 AlphaUse
21088
21089                                 MoveResistance uint8
21090
21091                                 LiquidMovePhysics bool
21092                         }))(obj)).Translucent
21093                         switch n := read8(r); n {
21094                         case 0:
21095                                 *p = false
21096                         case 1:
21097                                 *p = true
21098                         default:
21099                                 chk(fmt.Errorf("invalid bool: %d", n))
21100                         }
21101                 }
21102                 {
21103                         p := &(*(*(struct {
21104                                 Param0 Content
21105
21106                                 Name   string
21107                                 Groups []Group
21108
21109                                 P1Type   Param1Type
21110                                 P2Type   Param2Type
21111                                 DrawType DrawType
21112
21113                                 Mesh  string
21114                                 Scale float32
21115                                 //mt:const uint8(6)
21116                                 Tiles        [6]TileDef
21117                                 OverlayTiles [6]TileDef
21118                                 //mt:const uint8(6)
21119                                 SpecialTiles [6]TileDef
21120
21121                                 Color   color.NRGBA
21122                                 Palette Texture
21123
21124                                 Waving       WaveType
21125                                 ConnectSides uint8
21126                                 ConnectTo    []Content
21127                                 InsideTint   color.NRGBA
21128                                 Level        uint8 // Must be < 128.
21129
21130                                 Translucent bool // Sunlight is scattered and becomes normal light.
21131                                 Transparent bool // Sunlight isn't scattered.
21132                                 LightSrc    uint8
21133
21134                                 GndContent   bool
21135                                 Collides     bool
21136                                 Pointable    bool
21137                                 Diggable     bool
21138                                 Climbable    bool
21139                                 Replaceable  bool
21140                                 OnRightClick bool
21141
21142                                 DmgPerSec int32
21143
21144                                 LiquidType   LiquidType
21145                                 FlowingAlt   string
21146                                 SrcAlt       string
21147                                 Viscosity    uint8 // 0-7
21148                                 LiqRenewable bool
21149                                 FlowRange    uint8
21150                                 DrownDmg     uint8
21151                                 Floodable    bool
21152
21153                                 DrawBox, ColBox, SelBox NodeBox
21154
21155                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21156
21157                                 LegacyFaceDir bool
21158                                 LegacyMounted bool
21159
21160                                 DigPredict string
21161
21162                                 MaxLvl uint8
21163
21164                                 AlphaUse
21165
21166                                 MoveResistance uint8
21167
21168                                 LiquidMovePhysics bool
21169                         }))(obj)).Transparent
21170                         switch n := read8(r); n {
21171                         case 0:
21172                                 *p = false
21173                         case 1:
21174                                 *p = true
21175                         default:
21176                                 chk(fmt.Errorf("invalid bool: %d", n))
21177                         }
21178                 }
21179                 {
21180                         p := &(*(*(struct {
21181                                 Param0 Content
21182
21183                                 Name   string
21184                                 Groups []Group
21185
21186                                 P1Type   Param1Type
21187                                 P2Type   Param2Type
21188                                 DrawType DrawType
21189
21190                                 Mesh  string
21191                                 Scale float32
21192                                 //mt:const uint8(6)
21193                                 Tiles        [6]TileDef
21194                                 OverlayTiles [6]TileDef
21195                                 //mt:const uint8(6)
21196                                 SpecialTiles [6]TileDef
21197
21198                                 Color   color.NRGBA
21199                                 Palette Texture
21200
21201                                 Waving       WaveType
21202                                 ConnectSides uint8
21203                                 ConnectTo    []Content
21204                                 InsideTint   color.NRGBA
21205                                 Level        uint8 // Must be < 128.
21206
21207                                 Translucent bool // Sunlight is scattered and becomes normal light.
21208                                 Transparent bool // Sunlight isn't scattered.
21209                                 LightSrc    uint8
21210
21211                                 GndContent   bool
21212                                 Collides     bool
21213                                 Pointable    bool
21214                                 Diggable     bool
21215                                 Climbable    bool
21216                                 Replaceable  bool
21217                                 OnRightClick bool
21218
21219                                 DmgPerSec int32
21220
21221                                 LiquidType   LiquidType
21222                                 FlowingAlt   string
21223                                 SrcAlt       string
21224                                 Viscosity    uint8 // 0-7
21225                                 LiqRenewable bool
21226                                 FlowRange    uint8
21227                                 DrownDmg     uint8
21228                                 Floodable    bool
21229
21230                                 DrawBox, ColBox, SelBox NodeBox
21231
21232                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21233
21234                                 LegacyFaceDir bool
21235                                 LegacyMounted bool
21236
21237                                 DigPredict string
21238
21239                                 MaxLvl uint8
21240
21241                                 AlphaUse
21242
21243                                 MoveResistance uint8
21244
21245                                 LiquidMovePhysics bool
21246                         }))(obj)).LightSrc
21247                         *p = read8(r)
21248                 }
21249                 {
21250                         p := &(*(*(struct {
21251                                 Param0 Content
21252
21253                                 Name   string
21254                                 Groups []Group
21255
21256                                 P1Type   Param1Type
21257                                 P2Type   Param2Type
21258                                 DrawType DrawType
21259
21260                                 Mesh  string
21261                                 Scale float32
21262                                 //mt:const uint8(6)
21263                                 Tiles        [6]TileDef
21264                                 OverlayTiles [6]TileDef
21265                                 //mt:const uint8(6)
21266                                 SpecialTiles [6]TileDef
21267
21268                                 Color   color.NRGBA
21269                                 Palette Texture
21270
21271                                 Waving       WaveType
21272                                 ConnectSides uint8
21273                                 ConnectTo    []Content
21274                                 InsideTint   color.NRGBA
21275                                 Level        uint8 // Must be < 128.
21276
21277                                 Translucent bool // Sunlight is scattered and becomes normal light.
21278                                 Transparent bool // Sunlight isn't scattered.
21279                                 LightSrc    uint8
21280
21281                                 GndContent   bool
21282                                 Collides     bool
21283                                 Pointable    bool
21284                                 Diggable     bool
21285                                 Climbable    bool
21286                                 Replaceable  bool
21287                                 OnRightClick bool
21288
21289                                 DmgPerSec int32
21290
21291                                 LiquidType   LiquidType
21292                                 FlowingAlt   string
21293                                 SrcAlt       string
21294                                 Viscosity    uint8 // 0-7
21295                                 LiqRenewable bool
21296                                 FlowRange    uint8
21297                                 DrownDmg     uint8
21298                                 Floodable    bool
21299
21300                                 DrawBox, ColBox, SelBox NodeBox
21301
21302                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21303
21304                                 LegacyFaceDir bool
21305                                 LegacyMounted bool
21306
21307                                 DigPredict string
21308
21309                                 MaxLvl uint8
21310
21311                                 AlphaUse
21312
21313                                 MoveResistance uint8
21314
21315                                 LiquidMovePhysics bool
21316                         }))(obj)).GndContent
21317                         switch n := read8(r); n {
21318                         case 0:
21319                                 *p = false
21320                         case 1:
21321                                 *p = true
21322                         default:
21323                                 chk(fmt.Errorf("invalid bool: %d", n))
21324                         }
21325                 }
21326                 {
21327                         p := &(*(*(struct {
21328                                 Param0 Content
21329
21330                                 Name   string
21331                                 Groups []Group
21332
21333                                 P1Type   Param1Type
21334                                 P2Type   Param2Type
21335                                 DrawType DrawType
21336
21337                                 Mesh  string
21338                                 Scale float32
21339                                 //mt:const uint8(6)
21340                                 Tiles        [6]TileDef
21341                                 OverlayTiles [6]TileDef
21342                                 //mt:const uint8(6)
21343                                 SpecialTiles [6]TileDef
21344
21345                                 Color   color.NRGBA
21346                                 Palette Texture
21347
21348                                 Waving       WaveType
21349                                 ConnectSides uint8
21350                                 ConnectTo    []Content
21351                                 InsideTint   color.NRGBA
21352                                 Level        uint8 // Must be < 128.
21353
21354                                 Translucent bool // Sunlight is scattered and becomes normal light.
21355                                 Transparent bool // Sunlight isn't scattered.
21356                                 LightSrc    uint8
21357
21358                                 GndContent   bool
21359                                 Collides     bool
21360                                 Pointable    bool
21361                                 Diggable     bool
21362                                 Climbable    bool
21363                                 Replaceable  bool
21364                                 OnRightClick bool
21365
21366                                 DmgPerSec int32
21367
21368                                 LiquidType   LiquidType
21369                                 FlowingAlt   string
21370                                 SrcAlt       string
21371                                 Viscosity    uint8 // 0-7
21372                                 LiqRenewable bool
21373                                 FlowRange    uint8
21374                                 DrownDmg     uint8
21375                                 Floodable    bool
21376
21377                                 DrawBox, ColBox, SelBox NodeBox
21378
21379                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21380
21381                                 LegacyFaceDir bool
21382                                 LegacyMounted bool
21383
21384                                 DigPredict string
21385
21386                                 MaxLvl uint8
21387
21388                                 AlphaUse
21389
21390                                 MoveResistance uint8
21391
21392                                 LiquidMovePhysics bool
21393                         }))(obj)).Collides
21394                         switch n := read8(r); n {
21395                         case 0:
21396                                 *p = false
21397                         case 1:
21398                                 *p = true
21399                         default:
21400                                 chk(fmt.Errorf("invalid bool: %d", n))
21401                         }
21402                 }
21403                 {
21404                         p := &(*(*(struct {
21405                                 Param0 Content
21406
21407                                 Name   string
21408                                 Groups []Group
21409
21410                                 P1Type   Param1Type
21411                                 P2Type   Param2Type
21412                                 DrawType DrawType
21413
21414                                 Mesh  string
21415                                 Scale float32
21416                                 //mt:const uint8(6)
21417                                 Tiles        [6]TileDef
21418                                 OverlayTiles [6]TileDef
21419                                 //mt:const uint8(6)
21420                                 SpecialTiles [6]TileDef
21421
21422                                 Color   color.NRGBA
21423                                 Palette Texture
21424
21425                                 Waving       WaveType
21426                                 ConnectSides uint8
21427                                 ConnectTo    []Content
21428                                 InsideTint   color.NRGBA
21429                                 Level        uint8 // Must be < 128.
21430
21431                                 Translucent bool // Sunlight is scattered and becomes normal light.
21432                                 Transparent bool // Sunlight isn't scattered.
21433                                 LightSrc    uint8
21434
21435                                 GndContent   bool
21436                                 Collides     bool
21437                                 Pointable    bool
21438                                 Diggable     bool
21439                                 Climbable    bool
21440                                 Replaceable  bool
21441                                 OnRightClick bool
21442
21443                                 DmgPerSec int32
21444
21445                                 LiquidType   LiquidType
21446                                 FlowingAlt   string
21447                                 SrcAlt       string
21448                                 Viscosity    uint8 // 0-7
21449                                 LiqRenewable bool
21450                                 FlowRange    uint8
21451                                 DrownDmg     uint8
21452                                 Floodable    bool
21453
21454                                 DrawBox, ColBox, SelBox NodeBox
21455
21456                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21457
21458                                 LegacyFaceDir bool
21459                                 LegacyMounted bool
21460
21461                                 DigPredict string
21462
21463                                 MaxLvl uint8
21464
21465                                 AlphaUse
21466
21467                                 MoveResistance uint8
21468
21469                                 LiquidMovePhysics bool
21470                         }))(obj)).Pointable
21471                         switch n := read8(r); n {
21472                         case 0:
21473                                 *p = false
21474                         case 1:
21475                                 *p = true
21476                         default:
21477                                 chk(fmt.Errorf("invalid bool: %d", n))
21478                         }
21479                 }
21480                 {
21481                         p := &(*(*(struct {
21482                                 Param0 Content
21483
21484                                 Name   string
21485                                 Groups []Group
21486
21487                                 P1Type   Param1Type
21488                                 P2Type   Param2Type
21489                                 DrawType DrawType
21490
21491                                 Mesh  string
21492                                 Scale float32
21493                                 //mt:const uint8(6)
21494                                 Tiles        [6]TileDef
21495                                 OverlayTiles [6]TileDef
21496                                 //mt:const uint8(6)
21497                                 SpecialTiles [6]TileDef
21498
21499                                 Color   color.NRGBA
21500                                 Palette Texture
21501
21502                                 Waving       WaveType
21503                                 ConnectSides uint8
21504                                 ConnectTo    []Content
21505                                 InsideTint   color.NRGBA
21506                                 Level        uint8 // Must be < 128.
21507
21508                                 Translucent bool // Sunlight is scattered and becomes normal light.
21509                                 Transparent bool // Sunlight isn't scattered.
21510                                 LightSrc    uint8
21511
21512                                 GndContent   bool
21513                                 Collides     bool
21514                                 Pointable    bool
21515                                 Diggable     bool
21516                                 Climbable    bool
21517                                 Replaceable  bool
21518                                 OnRightClick bool
21519
21520                                 DmgPerSec int32
21521
21522                                 LiquidType   LiquidType
21523                                 FlowingAlt   string
21524                                 SrcAlt       string
21525                                 Viscosity    uint8 // 0-7
21526                                 LiqRenewable bool
21527                                 FlowRange    uint8
21528                                 DrownDmg     uint8
21529                                 Floodable    bool
21530
21531                                 DrawBox, ColBox, SelBox NodeBox
21532
21533                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21534
21535                                 LegacyFaceDir bool
21536                                 LegacyMounted bool
21537
21538                                 DigPredict string
21539
21540                                 MaxLvl uint8
21541
21542                                 AlphaUse
21543
21544                                 MoveResistance uint8
21545
21546                                 LiquidMovePhysics bool
21547                         }))(obj)).Diggable
21548                         switch n := read8(r); n {
21549                         case 0:
21550                                 *p = false
21551                         case 1:
21552                                 *p = true
21553                         default:
21554                                 chk(fmt.Errorf("invalid bool: %d", n))
21555                         }
21556                 }
21557                 {
21558                         p := &(*(*(struct {
21559                                 Param0 Content
21560
21561                                 Name   string
21562                                 Groups []Group
21563
21564                                 P1Type   Param1Type
21565                                 P2Type   Param2Type
21566                                 DrawType DrawType
21567
21568                                 Mesh  string
21569                                 Scale float32
21570                                 //mt:const uint8(6)
21571                                 Tiles        [6]TileDef
21572                                 OverlayTiles [6]TileDef
21573                                 //mt:const uint8(6)
21574                                 SpecialTiles [6]TileDef
21575
21576                                 Color   color.NRGBA
21577                                 Palette Texture
21578
21579                                 Waving       WaveType
21580                                 ConnectSides uint8
21581                                 ConnectTo    []Content
21582                                 InsideTint   color.NRGBA
21583                                 Level        uint8 // Must be < 128.
21584
21585                                 Translucent bool // Sunlight is scattered and becomes normal light.
21586                                 Transparent bool // Sunlight isn't scattered.
21587                                 LightSrc    uint8
21588
21589                                 GndContent   bool
21590                                 Collides     bool
21591                                 Pointable    bool
21592                                 Diggable     bool
21593                                 Climbable    bool
21594                                 Replaceable  bool
21595                                 OnRightClick bool
21596
21597                                 DmgPerSec int32
21598
21599                                 LiquidType   LiquidType
21600                                 FlowingAlt   string
21601                                 SrcAlt       string
21602                                 Viscosity    uint8 // 0-7
21603                                 LiqRenewable bool
21604                                 FlowRange    uint8
21605                                 DrownDmg     uint8
21606                                 Floodable    bool
21607
21608                                 DrawBox, ColBox, SelBox NodeBox
21609
21610                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21611
21612                                 LegacyFaceDir bool
21613                                 LegacyMounted bool
21614
21615                                 DigPredict string
21616
21617                                 MaxLvl uint8
21618
21619                                 AlphaUse
21620
21621                                 MoveResistance uint8
21622
21623                                 LiquidMovePhysics bool
21624                         }))(obj)).Climbable
21625                         switch n := read8(r); n {
21626                         case 0:
21627                                 *p = false
21628                         case 1:
21629                                 *p = true
21630                         default:
21631                                 chk(fmt.Errorf("invalid bool: %d", n))
21632                         }
21633                 }
21634                 {
21635                         p := &(*(*(struct {
21636                                 Param0 Content
21637
21638                                 Name   string
21639                                 Groups []Group
21640
21641                                 P1Type   Param1Type
21642                                 P2Type   Param2Type
21643                                 DrawType DrawType
21644
21645                                 Mesh  string
21646                                 Scale float32
21647                                 //mt:const uint8(6)
21648                                 Tiles        [6]TileDef
21649                                 OverlayTiles [6]TileDef
21650                                 //mt:const uint8(6)
21651                                 SpecialTiles [6]TileDef
21652
21653                                 Color   color.NRGBA
21654                                 Palette Texture
21655
21656                                 Waving       WaveType
21657                                 ConnectSides uint8
21658                                 ConnectTo    []Content
21659                                 InsideTint   color.NRGBA
21660                                 Level        uint8 // Must be < 128.
21661
21662                                 Translucent bool // Sunlight is scattered and becomes normal light.
21663                                 Transparent bool // Sunlight isn't scattered.
21664                                 LightSrc    uint8
21665
21666                                 GndContent   bool
21667                                 Collides     bool
21668                                 Pointable    bool
21669                                 Diggable     bool
21670                                 Climbable    bool
21671                                 Replaceable  bool
21672                                 OnRightClick bool
21673
21674                                 DmgPerSec int32
21675
21676                                 LiquidType   LiquidType
21677                                 FlowingAlt   string
21678                                 SrcAlt       string
21679                                 Viscosity    uint8 // 0-7
21680                                 LiqRenewable bool
21681                                 FlowRange    uint8
21682                                 DrownDmg     uint8
21683                                 Floodable    bool
21684
21685                                 DrawBox, ColBox, SelBox NodeBox
21686
21687                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21688
21689                                 LegacyFaceDir bool
21690                                 LegacyMounted bool
21691
21692                                 DigPredict string
21693
21694                                 MaxLvl uint8
21695
21696                                 AlphaUse
21697
21698                                 MoveResistance uint8
21699
21700                                 LiquidMovePhysics bool
21701                         }))(obj)).Replaceable
21702                         switch n := read8(r); n {
21703                         case 0:
21704                                 *p = false
21705                         case 1:
21706                                 *p = true
21707                         default:
21708                                 chk(fmt.Errorf("invalid bool: %d", n))
21709                         }
21710                 }
21711                 {
21712                         p := &(*(*(struct {
21713                                 Param0 Content
21714
21715                                 Name   string
21716                                 Groups []Group
21717
21718                                 P1Type   Param1Type
21719                                 P2Type   Param2Type
21720                                 DrawType DrawType
21721
21722                                 Mesh  string
21723                                 Scale float32
21724                                 //mt:const uint8(6)
21725                                 Tiles        [6]TileDef
21726                                 OverlayTiles [6]TileDef
21727                                 //mt:const uint8(6)
21728                                 SpecialTiles [6]TileDef
21729
21730                                 Color   color.NRGBA
21731                                 Palette Texture
21732
21733                                 Waving       WaveType
21734                                 ConnectSides uint8
21735                                 ConnectTo    []Content
21736                                 InsideTint   color.NRGBA
21737                                 Level        uint8 // Must be < 128.
21738
21739                                 Translucent bool // Sunlight is scattered and becomes normal light.
21740                                 Transparent bool // Sunlight isn't scattered.
21741                                 LightSrc    uint8
21742
21743                                 GndContent   bool
21744                                 Collides     bool
21745                                 Pointable    bool
21746                                 Diggable     bool
21747                                 Climbable    bool
21748                                 Replaceable  bool
21749                                 OnRightClick bool
21750
21751                                 DmgPerSec int32
21752
21753                                 LiquidType   LiquidType
21754                                 FlowingAlt   string
21755                                 SrcAlt       string
21756                                 Viscosity    uint8 // 0-7
21757                                 LiqRenewable bool
21758                                 FlowRange    uint8
21759                                 DrownDmg     uint8
21760                                 Floodable    bool
21761
21762                                 DrawBox, ColBox, SelBox NodeBox
21763
21764                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21765
21766                                 LegacyFaceDir bool
21767                                 LegacyMounted bool
21768
21769                                 DigPredict string
21770
21771                                 MaxLvl uint8
21772
21773                                 AlphaUse
21774
21775                                 MoveResistance uint8
21776
21777                                 LiquidMovePhysics bool
21778                         }))(obj)).OnRightClick
21779                         switch n := read8(r); n {
21780                         case 0:
21781                                 *p = false
21782                         case 1:
21783                                 *p = true
21784                         default:
21785                                 chk(fmt.Errorf("invalid bool: %d", n))
21786                         }
21787                 }
21788                 {
21789                         p := &(*(*(struct {
21790                                 Param0 Content
21791
21792                                 Name   string
21793                                 Groups []Group
21794
21795                                 P1Type   Param1Type
21796                                 P2Type   Param2Type
21797                                 DrawType DrawType
21798
21799                                 Mesh  string
21800                                 Scale float32
21801                                 //mt:const uint8(6)
21802                                 Tiles        [6]TileDef
21803                                 OverlayTiles [6]TileDef
21804                                 //mt:const uint8(6)
21805                                 SpecialTiles [6]TileDef
21806
21807                                 Color   color.NRGBA
21808                                 Palette Texture
21809
21810                                 Waving       WaveType
21811                                 ConnectSides uint8
21812                                 ConnectTo    []Content
21813                                 InsideTint   color.NRGBA
21814                                 Level        uint8 // Must be < 128.
21815
21816                                 Translucent bool // Sunlight is scattered and becomes normal light.
21817                                 Transparent bool // Sunlight isn't scattered.
21818                                 LightSrc    uint8
21819
21820                                 GndContent   bool
21821                                 Collides     bool
21822                                 Pointable    bool
21823                                 Diggable     bool
21824                                 Climbable    bool
21825                                 Replaceable  bool
21826                                 OnRightClick bool
21827
21828                                 DmgPerSec int32
21829
21830                                 LiquidType   LiquidType
21831                                 FlowingAlt   string
21832                                 SrcAlt       string
21833                                 Viscosity    uint8 // 0-7
21834                                 LiqRenewable bool
21835                                 FlowRange    uint8
21836                                 DrownDmg     uint8
21837                                 Floodable    bool
21838
21839                                 DrawBox, ColBox, SelBox NodeBox
21840
21841                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21842
21843                                 LegacyFaceDir bool
21844                                 LegacyMounted bool
21845
21846                                 DigPredict string
21847
21848                                 MaxLvl uint8
21849
21850                                 AlphaUse
21851
21852                                 MoveResistance uint8
21853
21854                                 LiquidMovePhysics bool
21855                         }))(obj)).DmgPerSec
21856                         *p = int32(read32(r))
21857                 }
21858                 if err := pcall(func() {
21859                         ((*(*(struct {
21860                                 Param0 Content
21861
21862                                 Name   string
21863                                 Groups []Group
21864
21865                                 P1Type   Param1Type
21866                                 P2Type   Param2Type
21867                                 DrawType DrawType
21868
21869                                 Mesh  string
21870                                 Scale float32
21871                                 //mt:const uint8(6)
21872                                 Tiles        [6]TileDef
21873                                 OverlayTiles [6]TileDef
21874                                 //mt:const uint8(6)
21875                                 SpecialTiles [6]TileDef
21876
21877                                 Color   color.NRGBA
21878                                 Palette Texture
21879
21880                                 Waving       WaveType
21881                                 ConnectSides uint8
21882                                 ConnectTo    []Content
21883                                 InsideTint   color.NRGBA
21884                                 Level        uint8 // Must be < 128.
21885
21886                                 Translucent bool // Sunlight is scattered and becomes normal light.
21887                                 Transparent bool // Sunlight isn't scattered.
21888                                 LightSrc    uint8
21889
21890                                 GndContent   bool
21891                                 Collides     bool
21892                                 Pointable    bool
21893                                 Diggable     bool
21894                                 Climbable    bool
21895                                 Replaceable  bool
21896                                 OnRightClick bool
21897
21898                                 DmgPerSec int32
21899
21900                                 LiquidType   LiquidType
21901                                 FlowingAlt   string
21902                                 SrcAlt       string
21903                                 Viscosity    uint8 // 0-7
21904                                 LiqRenewable bool
21905                                 FlowRange    uint8
21906                                 DrownDmg     uint8
21907                                 Floodable    bool
21908
21909                                 DrawBox, ColBox, SelBox NodeBox
21910
21911                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21912
21913                                 LegacyFaceDir bool
21914                                 LegacyMounted bool
21915
21916                                 DigPredict string
21917
21918                                 MaxLvl uint8
21919
21920                                 AlphaUse
21921
21922                                 MoveResistance uint8
21923
21924                                 LiquidMovePhysics bool
21925                         }))(obj)).LiquidType).deserialize(r)
21926                 }); err != nil {
21927                         if err == io.EOF {
21928                                 chk(io.EOF)
21929                         }
21930                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LiquidType", err))
21931                 }
21932                 var local263 []uint8
21933                 var local264 uint16
21934                 {
21935                         p := &local264
21936                         *p = read16(r)
21937                 }
21938                 (local263) = make([]uint8, local264)
21939                 {
21940                         _, err := io.ReadFull(r, (local263)[:])
21941                         chk(err)
21942                 }
21943                 ((*(*(struct {
21944                         Param0 Content
21945
21946                         Name   string
21947                         Groups []Group
21948
21949                         P1Type   Param1Type
21950                         P2Type   Param2Type
21951                         DrawType DrawType
21952
21953                         Mesh  string
21954                         Scale float32
21955                         //mt:const uint8(6)
21956                         Tiles        [6]TileDef
21957                         OverlayTiles [6]TileDef
21958                         //mt:const uint8(6)
21959                         SpecialTiles [6]TileDef
21960
21961                         Color   color.NRGBA
21962                         Palette Texture
21963
21964                         Waving       WaveType
21965                         ConnectSides uint8
21966                         ConnectTo    []Content
21967                         InsideTint   color.NRGBA
21968                         Level        uint8 // Must be < 128.
21969
21970                         Translucent bool // Sunlight is scattered and becomes normal light.
21971                         Transparent bool // Sunlight isn't scattered.
21972                         LightSrc    uint8
21973
21974                         GndContent   bool
21975                         Collides     bool
21976                         Pointable    bool
21977                         Diggable     bool
21978                         Climbable    bool
21979                         Replaceable  bool
21980                         OnRightClick bool
21981
21982                         DmgPerSec int32
21983
21984                         LiquidType   LiquidType
21985                         FlowingAlt   string
21986                         SrcAlt       string
21987                         Viscosity    uint8 // 0-7
21988                         LiqRenewable bool
21989                         FlowRange    uint8
21990                         DrownDmg     uint8
21991                         Floodable    bool
21992
21993                         DrawBox, ColBox, SelBox NodeBox
21994
21995                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21996
21997                         LegacyFaceDir bool
21998                         LegacyMounted bool
21999
22000                         DigPredict string
22001
22002                         MaxLvl uint8
22003
22004                         AlphaUse
22005
22006                         MoveResistance uint8
22007
22008                         LiquidMovePhysics bool
22009                 }))(obj)).FlowingAlt) = string(local263)
22010                 var local265 []uint8
22011                 var local266 uint16
22012                 {
22013                         p := &local266
22014                         *p = read16(r)
22015                 }
22016                 (local265) = make([]uint8, local266)
22017                 {
22018                         _, err := io.ReadFull(r, (local265)[:])
22019                         chk(err)
22020                 }
22021                 ((*(*(struct {
22022                         Param0 Content
22023
22024                         Name   string
22025                         Groups []Group
22026
22027                         P1Type   Param1Type
22028                         P2Type   Param2Type
22029                         DrawType DrawType
22030
22031                         Mesh  string
22032                         Scale float32
22033                         //mt:const uint8(6)
22034                         Tiles        [6]TileDef
22035                         OverlayTiles [6]TileDef
22036                         //mt:const uint8(6)
22037                         SpecialTiles [6]TileDef
22038
22039                         Color   color.NRGBA
22040                         Palette Texture
22041
22042                         Waving       WaveType
22043                         ConnectSides uint8
22044                         ConnectTo    []Content
22045                         InsideTint   color.NRGBA
22046                         Level        uint8 // Must be < 128.
22047
22048                         Translucent bool // Sunlight is scattered and becomes normal light.
22049                         Transparent bool // Sunlight isn't scattered.
22050                         LightSrc    uint8
22051
22052                         GndContent   bool
22053                         Collides     bool
22054                         Pointable    bool
22055                         Diggable     bool
22056                         Climbable    bool
22057                         Replaceable  bool
22058                         OnRightClick bool
22059
22060                         DmgPerSec int32
22061
22062                         LiquidType   LiquidType
22063                         FlowingAlt   string
22064                         SrcAlt       string
22065                         Viscosity    uint8 // 0-7
22066                         LiqRenewable bool
22067                         FlowRange    uint8
22068                         DrownDmg     uint8
22069                         Floodable    bool
22070
22071                         DrawBox, ColBox, SelBox NodeBox
22072
22073                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22074
22075                         LegacyFaceDir bool
22076                         LegacyMounted bool
22077
22078                         DigPredict string
22079
22080                         MaxLvl uint8
22081
22082                         AlphaUse
22083
22084                         MoveResistance uint8
22085
22086                         LiquidMovePhysics bool
22087                 }))(obj)).SrcAlt) = string(local265)
22088                 {
22089                         p := &(*(*(struct {
22090                                 Param0 Content
22091
22092                                 Name   string
22093                                 Groups []Group
22094
22095                                 P1Type   Param1Type
22096                                 P2Type   Param2Type
22097                                 DrawType DrawType
22098
22099                                 Mesh  string
22100                                 Scale float32
22101                                 //mt:const uint8(6)
22102                                 Tiles        [6]TileDef
22103                                 OverlayTiles [6]TileDef
22104                                 //mt:const uint8(6)
22105                                 SpecialTiles [6]TileDef
22106
22107                                 Color   color.NRGBA
22108                                 Palette Texture
22109
22110                                 Waving       WaveType
22111                                 ConnectSides uint8
22112                                 ConnectTo    []Content
22113                                 InsideTint   color.NRGBA
22114                                 Level        uint8 // Must be < 128.
22115
22116                                 Translucent bool // Sunlight is scattered and becomes normal light.
22117                                 Transparent bool // Sunlight isn't scattered.
22118                                 LightSrc    uint8
22119
22120                                 GndContent   bool
22121                                 Collides     bool
22122                                 Pointable    bool
22123                                 Diggable     bool
22124                                 Climbable    bool
22125                                 Replaceable  bool
22126                                 OnRightClick bool
22127
22128                                 DmgPerSec int32
22129
22130                                 LiquidType   LiquidType
22131                                 FlowingAlt   string
22132                                 SrcAlt       string
22133                                 Viscosity    uint8 // 0-7
22134                                 LiqRenewable bool
22135                                 FlowRange    uint8
22136                                 DrownDmg     uint8
22137                                 Floodable    bool
22138
22139                                 DrawBox, ColBox, SelBox NodeBox
22140
22141                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22142
22143                                 LegacyFaceDir bool
22144                                 LegacyMounted bool
22145
22146                                 DigPredict string
22147
22148                                 MaxLvl uint8
22149
22150                                 AlphaUse
22151
22152                                 MoveResistance uint8
22153
22154                                 LiquidMovePhysics bool
22155                         }))(obj)).Viscosity
22156                         *p = read8(r)
22157                 }
22158                 {
22159                         p := &(*(*(struct {
22160                                 Param0 Content
22161
22162                                 Name   string
22163                                 Groups []Group
22164
22165                                 P1Type   Param1Type
22166                                 P2Type   Param2Type
22167                                 DrawType DrawType
22168
22169                                 Mesh  string
22170                                 Scale float32
22171                                 //mt:const uint8(6)
22172                                 Tiles        [6]TileDef
22173                                 OverlayTiles [6]TileDef
22174                                 //mt:const uint8(6)
22175                                 SpecialTiles [6]TileDef
22176
22177                                 Color   color.NRGBA
22178                                 Palette Texture
22179
22180                                 Waving       WaveType
22181                                 ConnectSides uint8
22182                                 ConnectTo    []Content
22183                                 InsideTint   color.NRGBA
22184                                 Level        uint8 // Must be < 128.
22185
22186                                 Translucent bool // Sunlight is scattered and becomes normal light.
22187                                 Transparent bool // Sunlight isn't scattered.
22188                                 LightSrc    uint8
22189
22190                                 GndContent   bool
22191                                 Collides     bool
22192                                 Pointable    bool
22193                                 Diggable     bool
22194                                 Climbable    bool
22195                                 Replaceable  bool
22196                                 OnRightClick bool
22197
22198                                 DmgPerSec int32
22199
22200                                 LiquidType   LiquidType
22201                                 FlowingAlt   string
22202                                 SrcAlt       string
22203                                 Viscosity    uint8 // 0-7
22204                                 LiqRenewable bool
22205                                 FlowRange    uint8
22206                                 DrownDmg     uint8
22207                                 Floodable    bool
22208
22209                                 DrawBox, ColBox, SelBox NodeBox
22210
22211                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22212
22213                                 LegacyFaceDir bool
22214                                 LegacyMounted bool
22215
22216                                 DigPredict string
22217
22218                                 MaxLvl uint8
22219
22220                                 AlphaUse
22221
22222                                 MoveResistance uint8
22223
22224                                 LiquidMovePhysics bool
22225                         }))(obj)).LiqRenewable
22226                         switch n := read8(r); n {
22227                         case 0:
22228                                 *p = false
22229                         case 1:
22230                                 *p = true
22231                         default:
22232                                 chk(fmt.Errorf("invalid bool: %d", n))
22233                         }
22234                 }
22235                 {
22236                         p := &(*(*(struct {
22237                                 Param0 Content
22238
22239                                 Name   string
22240                                 Groups []Group
22241
22242                                 P1Type   Param1Type
22243                                 P2Type   Param2Type
22244                                 DrawType DrawType
22245
22246                                 Mesh  string
22247                                 Scale float32
22248                                 //mt:const uint8(6)
22249                                 Tiles        [6]TileDef
22250                                 OverlayTiles [6]TileDef
22251                                 //mt:const uint8(6)
22252                                 SpecialTiles [6]TileDef
22253
22254                                 Color   color.NRGBA
22255                                 Palette Texture
22256
22257                                 Waving       WaveType
22258                                 ConnectSides uint8
22259                                 ConnectTo    []Content
22260                                 InsideTint   color.NRGBA
22261                                 Level        uint8 // Must be < 128.
22262
22263                                 Translucent bool // Sunlight is scattered and becomes normal light.
22264                                 Transparent bool // Sunlight isn't scattered.
22265                                 LightSrc    uint8
22266
22267                                 GndContent   bool
22268                                 Collides     bool
22269                                 Pointable    bool
22270                                 Diggable     bool
22271                                 Climbable    bool
22272                                 Replaceable  bool
22273                                 OnRightClick bool
22274
22275                                 DmgPerSec int32
22276
22277                                 LiquidType   LiquidType
22278                                 FlowingAlt   string
22279                                 SrcAlt       string
22280                                 Viscosity    uint8 // 0-7
22281                                 LiqRenewable bool
22282                                 FlowRange    uint8
22283                                 DrownDmg     uint8
22284                                 Floodable    bool
22285
22286                                 DrawBox, ColBox, SelBox NodeBox
22287
22288                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22289
22290                                 LegacyFaceDir bool
22291                                 LegacyMounted bool
22292
22293                                 DigPredict string
22294
22295                                 MaxLvl uint8
22296
22297                                 AlphaUse
22298
22299                                 MoveResistance uint8
22300
22301                                 LiquidMovePhysics bool
22302                         }))(obj)).FlowRange
22303                         *p = read8(r)
22304                 }
22305                 {
22306                         p := &(*(*(struct {
22307                                 Param0 Content
22308
22309                                 Name   string
22310                                 Groups []Group
22311
22312                                 P1Type   Param1Type
22313                                 P2Type   Param2Type
22314                                 DrawType DrawType
22315
22316                                 Mesh  string
22317                                 Scale float32
22318                                 //mt:const uint8(6)
22319                                 Tiles        [6]TileDef
22320                                 OverlayTiles [6]TileDef
22321                                 //mt:const uint8(6)
22322                                 SpecialTiles [6]TileDef
22323
22324                                 Color   color.NRGBA
22325                                 Palette Texture
22326
22327                                 Waving       WaveType
22328                                 ConnectSides uint8
22329                                 ConnectTo    []Content
22330                                 InsideTint   color.NRGBA
22331                                 Level        uint8 // Must be < 128.
22332
22333                                 Translucent bool // Sunlight is scattered and becomes normal light.
22334                                 Transparent bool // Sunlight isn't scattered.
22335                                 LightSrc    uint8
22336
22337                                 GndContent   bool
22338                                 Collides     bool
22339                                 Pointable    bool
22340                                 Diggable     bool
22341                                 Climbable    bool
22342                                 Replaceable  bool
22343                                 OnRightClick bool
22344
22345                                 DmgPerSec int32
22346
22347                                 LiquidType   LiquidType
22348                                 FlowingAlt   string
22349                                 SrcAlt       string
22350                                 Viscosity    uint8 // 0-7
22351                                 LiqRenewable bool
22352                                 FlowRange    uint8
22353                                 DrownDmg     uint8
22354                                 Floodable    bool
22355
22356                                 DrawBox, ColBox, SelBox NodeBox
22357
22358                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22359
22360                                 LegacyFaceDir bool
22361                                 LegacyMounted bool
22362
22363                                 DigPredict string
22364
22365                                 MaxLvl uint8
22366
22367                                 AlphaUse
22368
22369                                 MoveResistance uint8
22370
22371                                 LiquidMovePhysics bool
22372                         }))(obj)).DrownDmg
22373                         *p = read8(r)
22374                 }
22375                 {
22376                         p := &(*(*(struct {
22377                                 Param0 Content
22378
22379                                 Name   string
22380                                 Groups []Group
22381
22382                                 P1Type   Param1Type
22383                                 P2Type   Param2Type
22384                                 DrawType DrawType
22385
22386                                 Mesh  string
22387                                 Scale float32
22388                                 //mt:const uint8(6)
22389                                 Tiles        [6]TileDef
22390                                 OverlayTiles [6]TileDef
22391                                 //mt:const uint8(6)
22392                                 SpecialTiles [6]TileDef
22393
22394                                 Color   color.NRGBA
22395                                 Palette Texture
22396
22397                                 Waving       WaveType
22398                                 ConnectSides uint8
22399                                 ConnectTo    []Content
22400                                 InsideTint   color.NRGBA
22401                                 Level        uint8 // Must be < 128.
22402
22403                                 Translucent bool // Sunlight is scattered and becomes normal light.
22404                                 Transparent bool // Sunlight isn't scattered.
22405                                 LightSrc    uint8
22406
22407                                 GndContent   bool
22408                                 Collides     bool
22409                                 Pointable    bool
22410                                 Diggable     bool
22411                                 Climbable    bool
22412                                 Replaceable  bool
22413                                 OnRightClick bool
22414
22415                                 DmgPerSec int32
22416
22417                                 LiquidType   LiquidType
22418                                 FlowingAlt   string
22419                                 SrcAlt       string
22420                                 Viscosity    uint8 // 0-7
22421                                 LiqRenewable bool
22422                                 FlowRange    uint8
22423                                 DrownDmg     uint8
22424                                 Floodable    bool
22425
22426                                 DrawBox, ColBox, SelBox NodeBox
22427
22428                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22429
22430                                 LegacyFaceDir bool
22431                                 LegacyMounted bool
22432
22433                                 DigPredict string
22434
22435                                 MaxLvl uint8
22436
22437                                 AlphaUse
22438
22439                                 MoveResistance uint8
22440
22441                                 LiquidMovePhysics bool
22442                         }))(obj)).Floodable
22443                         switch n := read8(r); n {
22444                         case 0:
22445                                 *p = false
22446                         case 1:
22447                                 *p = true
22448                         default:
22449                                 chk(fmt.Errorf("invalid bool: %d", n))
22450                         }
22451                 }
22452                 if err := pcall(func() {
22453                         ((*(*(struct {
22454                                 Param0 Content
22455
22456                                 Name   string
22457                                 Groups []Group
22458
22459                                 P1Type   Param1Type
22460                                 P2Type   Param2Type
22461                                 DrawType DrawType
22462
22463                                 Mesh  string
22464                                 Scale float32
22465                                 //mt:const uint8(6)
22466                                 Tiles        [6]TileDef
22467                                 OverlayTiles [6]TileDef
22468                                 //mt:const uint8(6)
22469                                 SpecialTiles [6]TileDef
22470
22471                                 Color   color.NRGBA
22472                                 Palette Texture
22473
22474                                 Waving       WaveType
22475                                 ConnectSides uint8
22476                                 ConnectTo    []Content
22477                                 InsideTint   color.NRGBA
22478                                 Level        uint8 // Must be < 128.
22479
22480                                 Translucent bool // Sunlight is scattered and becomes normal light.
22481                                 Transparent bool // Sunlight isn't scattered.
22482                                 LightSrc    uint8
22483
22484                                 GndContent   bool
22485                                 Collides     bool
22486                                 Pointable    bool
22487                                 Diggable     bool
22488                                 Climbable    bool
22489                                 Replaceable  bool
22490                                 OnRightClick bool
22491
22492                                 DmgPerSec int32
22493
22494                                 LiquidType   LiquidType
22495                                 FlowingAlt   string
22496                                 SrcAlt       string
22497                                 Viscosity    uint8 // 0-7
22498                                 LiqRenewable bool
22499                                 FlowRange    uint8
22500                                 DrownDmg     uint8
22501                                 Floodable    bool
22502
22503                                 DrawBox, ColBox, SelBox NodeBox
22504
22505                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22506
22507                                 LegacyFaceDir bool
22508                                 LegacyMounted bool
22509
22510                                 DigPredict string
22511
22512                                 MaxLvl uint8
22513
22514                                 AlphaUse
22515
22516                                 MoveResistance uint8
22517
22518                                 LiquidMovePhysics bool
22519                         }))(obj)).DrawBox).deserialize(r)
22520                 }); err != nil {
22521                         if err == io.EOF {
22522                                 chk(io.EOF)
22523                         }
22524                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22525                 }
22526                 if err := pcall(func() {
22527                         ((*(*(struct {
22528                                 Param0 Content
22529
22530                                 Name   string
22531                                 Groups []Group
22532
22533                                 P1Type   Param1Type
22534                                 P2Type   Param2Type
22535                                 DrawType DrawType
22536
22537                                 Mesh  string
22538                                 Scale float32
22539                                 //mt:const uint8(6)
22540                                 Tiles        [6]TileDef
22541                                 OverlayTiles [6]TileDef
22542                                 //mt:const uint8(6)
22543                                 SpecialTiles [6]TileDef
22544
22545                                 Color   color.NRGBA
22546                                 Palette Texture
22547
22548                                 Waving       WaveType
22549                                 ConnectSides uint8
22550                                 ConnectTo    []Content
22551                                 InsideTint   color.NRGBA
22552                                 Level        uint8 // Must be < 128.
22553
22554                                 Translucent bool // Sunlight is scattered and becomes normal light.
22555                                 Transparent bool // Sunlight isn't scattered.
22556                                 LightSrc    uint8
22557
22558                                 GndContent   bool
22559                                 Collides     bool
22560                                 Pointable    bool
22561                                 Diggable     bool
22562                                 Climbable    bool
22563                                 Replaceable  bool
22564                                 OnRightClick bool
22565
22566                                 DmgPerSec int32
22567
22568                                 LiquidType   LiquidType
22569                                 FlowingAlt   string
22570                                 SrcAlt       string
22571                                 Viscosity    uint8 // 0-7
22572                                 LiqRenewable bool
22573                                 FlowRange    uint8
22574                                 DrownDmg     uint8
22575                                 Floodable    bool
22576
22577                                 DrawBox, ColBox, SelBox NodeBox
22578
22579                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22580
22581                                 LegacyFaceDir bool
22582                                 LegacyMounted bool
22583
22584                                 DigPredict string
22585
22586                                 MaxLvl uint8
22587
22588                                 AlphaUse
22589
22590                                 MoveResistance uint8
22591
22592                                 LiquidMovePhysics bool
22593                         }))(obj)).ColBox).deserialize(r)
22594                 }); err != nil {
22595                         if err == io.EOF {
22596                                 chk(io.EOF)
22597                         }
22598                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22599                 }
22600                 if err := pcall(func() {
22601                         ((*(*(struct {
22602                                 Param0 Content
22603
22604                                 Name   string
22605                                 Groups []Group
22606
22607                                 P1Type   Param1Type
22608                                 P2Type   Param2Type
22609                                 DrawType DrawType
22610
22611                                 Mesh  string
22612                                 Scale float32
22613                                 //mt:const uint8(6)
22614                                 Tiles        [6]TileDef
22615                                 OverlayTiles [6]TileDef
22616                                 //mt:const uint8(6)
22617                                 SpecialTiles [6]TileDef
22618
22619                                 Color   color.NRGBA
22620                                 Palette Texture
22621
22622                                 Waving       WaveType
22623                                 ConnectSides uint8
22624                                 ConnectTo    []Content
22625                                 InsideTint   color.NRGBA
22626                                 Level        uint8 // Must be < 128.
22627
22628                                 Translucent bool // Sunlight is scattered and becomes normal light.
22629                                 Transparent bool // Sunlight isn't scattered.
22630                                 LightSrc    uint8
22631
22632                                 GndContent   bool
22633                                 Collides     bool
22634                                 Pointable    bool
22635                                 Diggable     bool
22636                                 Climbable    bool
22637                                 Replaceable  bool
22638                                 OnRightClick bool
22639
22640                                 DmgPerSec int32
22641
22642                                 LiquidType   LiquidType
22643                                 FlowingAlt   string
22644                                 SrcAlt       string
22645                                 Viscosity    uint8 // 0-7
22646                                 LiqRenewable bool
22647                                 FlowRange    uint8
22648                                 DrownDmg     uint8
22649                                 Floodable    bool
22650
22651                                 DrawBox, ColBox, SelBox NodeBox
22652
22653                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22654
22655                                 LegacyFaceDir bool
22656                                 LegacyMounted bool
22657
22658                                 DigPredict string
22659
22660                                 MaxLvl uint8
22661
22662                                 AlphaUse
22663
22664                                 MoveResistance uint8
22665
22666                                 LiquidMovePhysics bool
22667                         }))(obj)).SelBox).deserialize(r)
22668                 }); err != nil {
22669                         if err == io.EOF {
22670                                 chk(io.EOF)
22671                         }
22672                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22673                 }
22674                 if err := pcall(func() {
22675                         ((*(*(struct {
22676                                 Param0 Content
22677
22678                                 Name   string
22679                                 Groups []Group
22680
22681                                 P1Type   Param1Type
22682                                 P2Type   Param2Type
22683                                 DrawType DrawType
22684
22685                                 Mesh  string
22686                                 Scale float32
22687                                 //mt:const uint8(6)
22688                                 Tiles        [6]TileDef
22689                                 OverlayTiles [6]TileDef
22690                                 //mt:const uint8(6)
22691                                 SpecialTiles [6]TileDef
22692
22693                                 Color   color.NRGBA
22694                                 Palette Texture
22695
22696                                 Waving       WaveType
22697                                 ConnectSides uint8
22698                                 ConnectTo    []Content
22699                                 InsideTint   color.NRGBA
22700                                 Level        uint8 // Must be < 128.
22701
22702                                 Translucent bool // Sunlight is scattered and becomes normal light.
22703                                 Transparent bool // Sunlight isn't scattered.
22704                                 LightSrc    uint8
22705
22706                                 GndContent   bool
22707                                 Collides     bool
22708                                 Pointable    bool
22709                                 Diggable     bool
22710                                 Climbable    bool
22711                                 Replaceable  bool
22712                                 OnRightClick bool
22713
22714                                 DmgPerSec int32
22715
22716                                 LiquidType   LiquidType
22717                                 FlowingAlt   string
22718                                 SrcAlt       string
22719                                 Viscosity    uint8 // 0-7
22720                                 LiqRenewable bool
22721                                 FlowRange    uint8
22722                                 DrownDmg     uint8
22723                                 Floodable    bool
22724
22725                                 DrawBox, ColBox, SelBox NodeBox
22726
22727                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22728
22729                                 LegacyFaceDir bool
22730                                 LegacyMounted bool
22731
22732                                 DigPredict string
22733
22734                                 MaxLvl uint8
22735
22736                                 AlphaUse
22737
22738                                 MoveResistance uint8
22739
22740                                 LiquidMovePhysics bool
22741                         }))(obj)).FootstepSnd).deserialize(r)
22742                 }); err != nil {
22743                         if err == io.EOF {
22744                                 chk(io.EOF)
22745                         }
22746                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22747                 }
22748                 if err := pcall(func() {
22749                         ((*(*(struct {
22750                                 Param0 Content
22751
22752                                 Name   string
22753                                 Groups []Group
22754
22755                                 P1Type   Param1Type
22756                                 P2Type   Param2Type
22757                                 DrawType DrawType
22758
22759                                 Mesh  string
22760                                 Scale float32
22761                                 //mt:const uint8(6)
22762                                 Tiles        [6]TileDef
22763                                 OverlayTiles [6]TileDef
22764                                 //mt:const uint8(6)
22765                                 SpecialTiles [6]TileDef
22766
22767                                 Color   color.NRGBA
22768                                 Palette Texture
22769
22770                                 Waving       WaveType
22771                                 ConnectSides uint8
22772                                 ConnectTo    []Content
22773                                 InsideTint   color.NRGBA
22774                                 Level        uint8 // Must be < 128.
22775
22776                                 Translucent bool // Sunlight is scattered and becomes normal light.
22777                                 Transparent bool // Sunlight isn't scattered.
22778                                 LightSrc    uint8
22779
22780                                 GndContent   bool
22781                                 Collides     bool
22782                                 Pointable    bool
22783                                 Diggable     bool
22784                                 Climbable    bool
22785                                 Replaceable  bool
22786                                 OnRightClick bool
22787
22788                                 DmgPerSec int32
22789
22790                                 LiquidType   LiquidType
22791                                 FlowingAlt   string
22792                                 SrcAlt       string
22793                                 Viscosity    uint8 // 0-7
22794                                 LiqRenewable bool
22795                                 FlowRange    uint8
22796                                 DrownDmg     uint8
22797                                 Floodable    bool
22798
22799                                 DrawBox, ColBox, SelBox NodeBox
22800
22801                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22802
22803                                 LegacyFaceDir bool
22804                                 LegacyMounted bool
22805
22806                                 DigPredict string
22807
22808                                 MaxLvl uint8
22809
22810                                 AlphaUse
22811
22812                                 MoveResistance uint8
22813
22814                                 LiquidMovePhysics bool
22815                         }))(obj)).DiggingSnd).deserialize(r)
22816                 }); err != nil {
22817                         if err == io.EOF {
22818                                 chk(io.EOF)
22819                         }
22820                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22821                 }
22822                 if err := pcall(func() {
22823                         ((*(*(struct {
22824                                 Param0 Content
22825
22826                                 Name   string
22827                                 Groups []Group
22828
22829                                 P1Type   Param1Type
22830                                 P2Type   Param2Type
22831                                 DrawType DrawType
22832
22833                                 Mesh  string
22834                                 Scale float32
22835                                 //mt:const uint8(6)
22836                                 Tiles        [6]TileDef
22837                                 OverlayTiles [6]TileDef
22838                                 //mt:const uint8(6)
22839                                 SpecialTiles [6]TileDef
22840
22841                                 Color   color.NRGBA
22842                                 Palette Texture
22843
22844                                 Waving       WaveType
22845                                 ConnectSides uint8
22846                                 ConnectTo    []Content
22847                                 InsideTint   color.NRGBA
22848                                 Level        uint8 // Must be < 128.
22849
22850                                 Translucent bool // Sunlight is scattered and becomes normal light.
22851                                 Transparent bool // Sunlight isn't scattered.
22852                                 LightSrc    uint8
22853
22854                                 GndContent   bool
22855                                 Collides     bool
22856                                 Pointable    bool
22857                                 Diggable     bool
22858                                 Climbable    bool
22859                                 Replaceable  bool
22860                                 OnRightClick bool
22861
22862                                 DmgPerSec int32
22863
22864                                 LiquidType   LiquidType
22865                                 FlowingAlt   string
22866                                 SrcAlt       string
22867                                 Viscosity    uint8 // 0-7
22868                                 LiqRenewable bool
22869                                 FlowRange    uint8
22870                                 DrownDmg     uint8
22871                                 Floodable    bool
22872
22873                                 DrawBox, ColBox, SelBox NodeBox
22874
22875                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22876
22877                                 LegacyFaceDir bool
22878                                 LegacyMounted bool
22879
22880                                 DigPredict string
22881
22882                                 MaxLvl uint8
22883
22884                                 AlphaUse
22885
22886                                 MoveResistance uint8
22887
22888                                 LiquidMovePhysics bool
22889                         }))(obj)).DugSnd).deserialize(r)
22890                 }); err != nil {
22891                         if err == io.EOF {
22892                                 chk(io.EOF)
22893                         }
22894                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22895                 }
22896                 {
22897                         p := &(*(*(struct {
22898                                 Param0 Content
22899
22900                                 Name   string
22901                                 Groups []Group
22902
22903                                 P1Type   Param1Type
22904                                 P2Type   Param2Type
22905                                 DrawType DrawType
22906
22907                                 Mesh  string
22908                                 Scale float32
22909                                 //mt:const uint8(6)
22910                                 Tiles        [6]TileDef
22911                                 OverlayTiles [6]TileDef
22912                                 //mt:const uint8(6)
22913                                 SpecialTiles [6]TileDef
22914
22915                                 Color   color.NRGBA
22916                                 Palette Texture
22917
22918                                 Waving       WaveType
22919                                 ConnectSides uint8
22920                                 ConnectTo    []Content
22921                                 InsideTint   color.NRGBA
22922                                 Level        uint8 // Must be < 128.
22923
22924                                 Translucent bool // Sunlight is scattered and becomes normal light.
22925                                 Transparent bool // Sunlight isn't scattered.
22926                                 LightSrc    uint8
22927
22928                                 GndContent   bool
22929                                 Collides     bool
22930                                 Pointable    bool
22931                                 Diggable     bool
22932                                 Climbable    bool
22933                                 Replaceable  bool
22934                                 OnRightClick bool
22935
22936                                 DmgPerSec int32
22937
22938                                 LiquidType   LiquidType
22939                                 FlowingAlt   string
22940                                 SrcAlt       string
22941                                 Viscosity    uint8 // 0-7
22942                                 LiqRenewable bool
22943                                 FlowRange    uint8
22944                                 DrownDmg     uint8
22945                                 Floodable    bool
22946
22947                                 DrawBox, ColBox, SelBox NodeBox
22948
22949                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22950
22951                                 LegacyFaceDir bool
22952                                 LegacyMounted bool
22953
22954                                 DigPredict string
22955
22956                                 MaxLvl uint8
22957
22958                                 AlphaUse
22959
22960                                 MoveResistance uint8
22961
22962                                 LiquidMovePhysics bool
22963                         }))(obj)).LegacyFaceDir
22964                         switch n := read8(r); n {
22965                         case 0:
22966                                 *p = false
22967                         case 1:
22968                                 *p = true
22969                         default:
22970                                 chk(fmt.Errorf("invalid bool: %d", n))
22971                         }
22972                 }
22973                 {
22974                         p := &(*(*(struct {
22975                                 Param0 Content
22976
22977                                 Name   string
22978                                 Groups []Group
22979
22980                                 P1Type   Param1Type
22981                                 P2Type   Param2Type
22982                                 DrawType DrawType
22983
22984                                 Mesh  string
22985                                 Scale float32
22986                                 //mt:const uint8(6)
22987                                 Tiles        [6]TileDef
22988                                 OverlayTiles [6]TileDef
22989                                 //mt:const uint8(6)
22990                                 SpecialTiles [6]TileDef
22991
22992                                 Color   color.NRGBA
22993                                 Palette Texture
22994
22995                                 Waving       WaveType
22996                                 ConnectSides uint8
22997                                 ConnectTo    []Content
22998                                 InsideTint   color.NRGBA
22999                                 Level        uint8 // Must be < 128.
23000
23001                                 Translucent bool // Sunlight is scattered and becomes normal light.
23002                                 Transparent bool // Sunlight isn't scattered.
23003                                 LightSrc    uint8
23004
23005                                 GndContent   bool
23006                                 Collides     bool
23007                                 Pointable    bool
23008                                 Diggable     bool
23009                                 Climbable    bool
23010                                 Replaceable  bool
23011                                 OnRightClick bool
23012
23013                                 DmgPerSec int32
23014
23015                                 LiquidType   LiquidType
23016                                 FlowingAlt   string
23017                                 SrcAlt       string
23018                                 Viscosity    uint8 // 0-7
23019                                 LiqRenewable bool
23020                                 FlowRange    uint8
23021                                 DrownDmg     uint8
23022                                 Floodable    bool
23023
23024                                 DrawBox, ColBox, SelBox NodeBox
23025
23026                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23027
23028                                 LegacyFaceDir bool
23029                                 LegacyMounted bool
23030
23031                                 DigPredict string
23032
23033                                 MaxLvl uint8
23034
23035                                 AlphaUse
23036
23037                                 MoveResistance uint8
23038
23039                                 LiquidMovePhysics bool
23040                         }))(obj)).LegacyMounted
23041                         switch n := read8(r); n {
23042                         case 0:
23043                                 *p = false
23044                         case 1:
23045                                 *p = true
23046                         default:
23047                                 chk(fmt.Errorf("invalid bool: %d", n))
23048                         }
23049                 }
23050                 var local267 []uint8
23051                 var local268 uint16
23052                 {
23053                         p := &local268
23054                         *p = read16(r)
23055                 }
23056                 (local267) = make([]uint8, local268)
23057                 {
23058                         _, err := io.ReadFull(r, (local267)[:])
23059                         chk(err)
23060                 }
23061                 ((*(*(struct {
23062                         Param0 Content
23063
23064                         Name   string
23065                         Groups []Group
23066
23067                         P1Type   Param1Type
23068                         P2Type   Param2Type
23069                         DrawType DrawType
23070
23071                         Mesh  string
23072                         Scale float32
23073                         //mt:const uint8(6)
23074                         Tiles        [6]TileDef
23075                         OverlayTiles [6]TileDef
23076                         //mt:const uint8(6)
23077                         SpecialTiles [6]TileDef
23078
23079                         Color   color.NRGBA
23080                         Palette Texture
23081
23082                         Waving       WaveType
23083                         ConnectSides uint8
23084                         ConnectTo    []Content
23085                         InsideTint   color.NRGBA
23086                         Level        uint8 // Must be < 128.
23087
23088                         Translucent bool // Sunlight is scattered and becomes normal light.
23089                         Transparent bool // Sunlight isn't scattered.
23090                         LightSrc    uint8
23091
23092                         GndContent   bool
23093                         Collides     bool
23094                         Pointable    bool
23095                         Diggable     bool
23096                         Climbable    bool
23097                         Replaceable  bool
23098                         OnRightClick bool
23099
23100                         DmgPerSec int32
23101
23102                         LiquidType   LiquidType
23103                         FlowingAlt   string
23104                         SrcAlt       string
23105                         Viscosity    uint8 // 0-7
23106                         LiqRenewable bool
23107                         FlowRange    uint8
23108                         DrownDmg     uint8
23109                         Floodable    bool
23110
23111                         DrawBox, ColBox, SelBox NodeBox
23112
23113                         FootstepSnd, DiggingSnd, DugSnd SoundDef
23114
23115                         LegacyFaceDir bool
23116                         LegacyMounted bool
23117
23118                         DigPredict string
23119
23120                         MaxLvl uint8
23121
23122                         AlphaUse
23123
23124                         MoveResistance uint8
23125
23126                         LiquidMovePhysics bool
23127                 }))(obj)).DigPredict) = string(local267)
23128                 {
23129                         p := &(*(*(struct {
23130                                 Param0 Content
23131
23132                                 Name   string
23133                                 Groups []Group
23134
23135                                 P1Type   Param1Type
23136                                 P2Type   Param2Type
23137                                 DrawType DrawType
23138
23139                                 Mesh  string
23140                                 Scale float32
23141                                 //mt:const uint8(6)
23142                                 Tiles        [6]TileDef
23143                                 OverlayTiles [6]TileDef
23144                                 //mt:const uint8(6)
23145                                 SpecialTiles [6]TileDef
23146
23147                                 Color   color.NRGBA
23148                                 Palette Texture
23149
23150                                 Waving       WaveType
23151                                 ConnectSides uint8
23152                                 ConnectTo    []Content
23153                                 InsideTint   color.NRGBA
23154                                 Level        uint8 // Must be < 128.
23155
23156                                 Translucent bool // Sunlight is scattered and becomes normal light.
23157                                 Transparent bool // Sunlight isn't scattered.
23158                                 LightSrc    uint8
23159
23160                                 GndContent   bool
23161                                 Collides     bool
23162                                 Pointable    bool
23163                                 Diggable     bool
23164                                 Climbable    bool
23165                                 Replaceable  bool
23166                                 OnRightClick bool
23167
23168                                 DmgPerSec int32
23169
23170                                 LiquidType   LiquidType
23171                                 FlowingAlt   string
23172                                 SrcAlt       string
23173                                 Viscosity    uint8 // 0-7
23174                                 LiqRenewable bool
23175                                 FlowRange    uint8
23176                                 DrownDmg     uint8
23177                                 Floodable    bool
23178
23179                                 DrawBox, ColBox, SelBox NodeBox
23180
23181                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23182
23183                                 LegacyFaceDir bool
23184                                 LegacyMounted bool
23185
23186                                 DigPredict string
23187
23188                                 MaxLvl uint8
23189
23190                                 AlphaUse
23191
23192                                 MoveResistance uint8
23193
23194                                 LiquidMovePhysics bool
23195                         }))(obj)).MaxLvl
23196                         *p = read8(r)
23197                 }
23198                 if err := pcall(func() {
23199                         ((*(*(struct {
23200                                 Param0 Content
23201
23202                                 Name   string
23203                                 Groups []Group
23204
23205                                 P1Type   Param1Type
23206                                 P2Type   Param2Type
23207                                 DrawType DrawType
23208
23209                                 Mesh  string
23210                                 Scale float32
23211                                 //mt:const uint8(6)
23212                                 Tiles        [6]TileDef
23213                                 OverlayTiles [6]TileDef
23214                                 //mt:const uint8(6)
23215                                 SpecialTiles [6]TileDef
23216
23217                                 Color   color.NRGBA
23218                                 Palette Texture
23219
23220                                 Waving       WaveType
23221                                 ConnectSides uint8
23222                                 ConnectTo    []Content
23223                                 InsideTint   color.NRGBA
23224                                 Level        uint8 // Must be < 128.
23225
23226                                 Translucent bool // Sunlight is scattered and becomes normal light.
23227                                 Transparent bool // Sunlight isn't scattered.
23228                                 LightSrc    uint8
23229
23230                                 GndContent   bool
23231                                 Collides     bool
23232                                 Pointable    bool
23233                                 Diggable     bool
23234                                 Climbable    bool
23235                                 Replaceable  bool
23236                                 OnRightClick bool
23237
23238                                 DmgPerSec int32
23239
23240                                 LiquidType   LiquidType
23241                                 FlowingAlt   string
23242                                 SrcAlt       string
23243                                 Viscosity    uint8 // 0-7
23244                                 LiqRenewable bool
23245                                 FlowRange    uint8
23246                                 DrownDmg     uint8
23247                                 Floodable    bool
23248
23249                                 DrawBox, ColBox, SelBox NodeBox
23250
23251                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23252
23253                                 LegacyFaceDir bool
23254                                 LegacyMounted bool
23255
23256                                 DigPredict string
23257
23258                                 MaxLvl uint8
23259
23260                                 AlphaUse
23261
23262                                 MoveResistance uint8
23263
23264                                 LiquidMovePhysics bool
23265                         }))(obj)).AlphaUse).deserialize(r)
23266                 }); err != nil {
23267                         if err == io.EOF {
23268                                 chk(io.EOF)
23269                         }
23270                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlphaUse", err))
23271                 }
23272                 {
23273                         p := &(*(*(struct {
23274                                 Param0 Content
23275
23276                                 Name   string
23277                                 Groups []Group
23278
23279                                 P1Type   Param1Type
23280                                 P2Type   Param2Type
23281                                 DrawType DrawType
23282
23283                                 Mesh  string
23284                                 Scale float32
23285                                 //mt:const uint8(6)
23286                                 Tiles        [6]TileDef
23287                                 OverlayTiles [6]TileDef
23288                                 //mt:const uint8(6)
23289                                 SpecialTiles [6]TileDef
23290
23291                                 Color   color.NRGBA
23292                                 Palette Texture
23293
23294                                 Waving       WaveType
23295                                 ConnectSides uint8
23296                                 ConnectTo    []Content
23297                                 InsideTint   color.NRGBA
23298                                 Level        uint8 // Must be < 128.
23299
23300                                 Translucent bool // Sunlight is scattered and becomes normal light.
23301                                 Transparent bool // Sunlight isn't scattered.
23302                                 LightSrc    uint8
23303
23304                                 GndContent   bool
23305                                 Collides     bool
23306                                 Pointable    bool
23307                                 Diggable     bool
23308                                 Climbable    bool
23309                                 Replaceable  bool
23310                                 OnRightClick bool
23311
23312                                 DmgPerSec int32
23313
23314                                 LiquidType   LiquidType
23315                                 FlowingAlt   string
23316                                 SrcAlt       string
23317                                 Viscosity    uint8 // 0-7
23318                                 LiqRenewable bool
23319                                 FlowRange    uint8
23320                                 DrownDmg     uint8
23321                                 Floodable    bool
23322
23323                                 DrawBox, ColBox, SelBox NodeBox
23324
23325                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23326
23327                                 LegacyFaceDir bool
23328                                 LegacyMounted bool
23329
23330                                 DigPredict string
23331
23332                                 MaxLvl uint8
23333
23334                                 AlphaUse
23335
23336                                 MoveResistance uint8
23337
23338                                 LiquidMovePhysics bool
23339                         }))(obj)).MoveResistance
23340                         *p = read8(r)
23341                 }
23342                 {
23343                         p := &(*(*(struct {
23344                                 Param0 Content
23345
23346                                 Name   string
23347                                 Groups []Group
23348
23349                                 P1Type   Param1Type
23350                                 P2Type   Param2Type
23351                                 DrawType DrawType
23352
23353                                 Mesh  string
23354                                 Scale float32
23355                                 //mt:const uint8(6)
23356                                 Tiles        [6]TileDef
23357                                 OverlayTiles [6]TileDef
23358                                 //mt:const uint8(6)
23359                                 SpecialTiles [6]TileDef
23360
23361                                 Color   color.NRGBA
23362                                 Palette Texture
23363
23364                                 Waving       WaveType
23365                                 ConnectSides uint8
23366                                 ConnectTo    []Content
23367                                 InsideTint   color.NRGBA
23368                                 Level        uint8 // Must be < 128.
23369
23370                                 Translucent bool // Sunlight is scattered and becomes normal light.
23371                                 Transparent bool // Sunlight isn't scattered.
23372                                 LightSrc    uint8
23373
23374                                 GndContent   bool
23375                                 Collides     bool
23376                                 Pointable    bool
23377                                 Diggable     bool
23378                                 Climbable    bool
23379                                 Replaceable  bool
23380                                 OnRightClick bool
23381
23382                                 DmgPerSec int32
23383
23384                                 LiquidType   LiquidType
23385                                 FlowingAlt   string
23386                                 SrcAlt       string
23387                                 Viscosity    uint8 // 0-7
23388                                 LiqRenewable bool
23389                                 FlowRange    uint8
23390                                 DrownDmg     uint8
23391                                 Floodable    bool
23392
23393                                 DrawBox, ColBox, SelBox NodeBox
23394
23395                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23396
23397                                 LegacyFaceDir bool
23398                                 LegacyMounted bool
23399
23400                                 DigPredict string
23401
23402                                 MaxLvl uint8
23403
23404                                 AlphaUse
23405
23406                                 MoveResistance uint8
23407
23408                                 LiquidMovePhysics bool
23409                         }))(obj)).LiquidMovePhysics
23410                         switch n := read8(r); n {
23411                         case 0:
23412                                 *p = false
23413                         case 1:
23414                                 *p = true
23415                         default:
23416                                 chk(fmt.Errorf("invalid bool: %d", n))
23417                         }
23418                 }
23419                 if r.N > 0 {
23420                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23421                 }
23422         }
23423 }
23424
23425 func (obj *PointedNode) serialize(w io.Writer) {
23426         for local269 := range (*(*(struct {
23427                 Under, Above [3]int16
23428         }))(obj)).Under {
23429                 {
23430                         x := ((*(*(struct {
23431                                 Under, Above [3]int16
23432                         }))(obj)).Under)[local269]
23433                         write16(w, uint16(x))
23434                 }
23435         }
23436         for local270 := range (*(*(struct {
23437                 Under, Above [3]int16
23438         }))(obj)).Above {
23439                 {
23440                         x := ((*(*(struct {
23441                                 Under, Above [3]int16
23442                         }))(obj)).Above)[local270]
23443                         write16(w, uint16(x))
23444                 }
23445         }
23446 }
23447
23448 func (obj *PointedNode) deserialize(r io.Reader) {
23449         for local271 := range (*(*(struct {
23450                 Under, Above [3]int16
23451         }))(obj)).Under {
23452                 {
23453                         p := &((*(*(struct {
23454                                 Under, Above [3]int16
23455                         }))(obj)).Under)[local271]
23456                         *p = int16(read16(r))
23457                 }
23458         }
23459         for local272 := range (*(*(struct {
23460                 Under, Above [3]int16
23461         }))(obj)).Above {
23462                 {
23463                         p := &((*(*(struct {
23464                                 Under, Above [3]int16
23465                         }))(obj)).Above)[local272]
23466                         *p = int16(read16(r))
23467                 }
23468         }
23469 }
23470
23471 func (obj *PointedAO) serialize(w io.Writer) {
23472         if err := pcall(func() {
23473                 ((*(*(struct {
23474                         ID AOID
23475                 }))(obj)).ID).serialize(w)
23476         }); err != nil {
23477                 if err == io.EOF {
23478                         chk(io.EOF)
23479                 }
23480                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23481         }
23482 }
23483
23484 func (obj *PointedAO) deserialize(r io.Reader) {
23485         if err := pcall(func() {
23486                 ((*(*(struct {
23487                         ID AOID
23488                 }))(obj)).ID).deserialize(r)
23489         }); err != nil {
23490                 if err == io.EOF {
23491                         chk(io.EOF)
23492                 }
23493                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23494         }
23495 }
23496
23497 func (obj *CompressionModes) serialize(w io.Writer) {
23498         {
23499                 x := *(*(uint16))(obj)
23500                 write16(w, uint16(x))
23501         }
23502 }
23503
23504 func (obj *CompressionModes) deserialize(r io.Reader) {
23505         {
23506                 p := &*(*(uint16))(obj)
23507                 *p = read16(r)
23508         }
23509 }
23510
23511 func (obj *PlayerPos) serialize(w io.Writer) {
23512         for local273 := range (*(*(struct {
23513                 Pos100, Vel100   [3]int32
23514                 Pitch100, Yaw100 int32
23515                 Keys             Keys
23516                 FOV80            uint8
23517                 WantedRange      uint8 // in MapBlks.
23518         }))(obj)).Pos100 {
23519                 {
23520                         x := ((*(*(struct {
23521                                 Pos100, Vel100   [3]int32
23522                                 Pitch100, Yaw100 int32
23523                                 Keys             Keys
23524                                 FOV80            uint8
23525                                 WantedRange      uint8 // in MapBlks.
23526                         }))(obj)).Pos100)[local273]
23527                         write32(w, uint32(x))
23528                 }
23529         }
23530         for local274 := range (*(*(struct {
23531                 Pos100, Vel100   [3]int32
23532                 Pitch100, Yaw100 int32
23533                 Keys             Keys
23534                 FOV80            uint8
23535                 WantedRange      uint8 // in MapBlks.
23536         }))(obj)).Vel100 {
23537                 {
23538                         x := ((*(*(struct {
23539                                 Pos100, Vel100   [3]int32
23540                                 Pitch100, Yaw100 int32
23541                                 Keys             Keys
23542                                 FOV80            uint8
23543                                 WantedRange      uint8 // in MapBlks.
23544                         }))(obj)).Vel100)[local274]
23545                         write32(w, uint32(x))
23546                 }
23547         }
23548         {
23549                 x := (*(*(struct {
23550                         Pos100, Vel100   [3]int32
23551                         Pitch100, Yaw100 int32
23552                         Keys             Keys
23553                         FOV80            uint8
23554                         WantedRange      uint8 // in MapBlks.
23555                 }))(obj)).Pitch100
23556                 write32(w, uint32(x))
23557         }
23558         {
23559                 x := (*(*(struct {
23560                         Pos100, Vel100   [3]int32
23561                         Pitch100, Yaw100 int32
23562                         Keys             Keys
23563                         FOV80            uint8
23564                         WantedRange      uint8 // in MapBlks.
23565                 }))(obj)).Yaw100
23566                 write32(w, uint32(x))
23567         }
23568         if err := pcall(func() {
23569                 ((*(*(struct {
23570                         Pos100, Vel100   [3]int32
23571                         Pitch100, Yaw100 int32
23572                         Keys             Keys
23573                         FOV80            uint8
23574                         WantedRange      uint8 // in MapBlks.
23575                 }))(obj)).Keys).serialize(w)
23576         }); err != nil {
23577                 if err == io.EOF {
23578                         chk(io.EOF)
23579                 }
23580                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Keys", err))
23581         }
23582         {
23583                 x := (*(*(struct {
23584                         Pos100, Vel100   [3]int32
23585                         Pitch100, Yaw100 int32
23586                         Keys             Keys
23587                         FOV80            uint8
23588                         WantedRange      uint8 // in MapBlks.
23589                 }))(obj)).FOV80
23590                 write8(w, uint8(x))
23591         }
23592         {
23593                 x := (*(*(struct {
23594                         Pos100, Vel100   [3]int32
23595                         Pitch100, Yaw100 int32
23596                         Keys             Keys
23597                         FOV80            uint8
23598                         WantedRange      uint8 // in MapBlks.
23599                 }))(obj)).WantedRange
23600                 write8(w, uint8(x))
23601         }
23602 }
23603
23604 func (obj *PlayerPos) deserialize(r io.Reader) {
23605         for local275 := range (*(*(struct {
23606                 Pos100, Vel100   [3]int32
23607                 Pitch100, Yaw100 int32
23608                 Keys             Keys
23609                 FOV80            uint8
23610                 WantedRange      uint8 // in MapBlks.
23611         }))(obj)).Pos100 {
23612                 {
23613                         p := &((*(*(struct {
23614                                 Pos100, Vel100   [3]int32
23615                                 Pitch100, Yaw100 int32
23616                                 Keys             Keys
23617                                 FOV80            uint8
23618                                 WantedRange      uint8 // in MapBlks.
23619                         }))(obj)).Pos100)[local275]
23620                         *p = int32(read32(r))
23621                 }
23622         }
23623         for local276 := range (*(*(struct {
23624                 Pos100, Vel100   [3]int32
23625                 Pitch100, Yaw100 int32
23626                 Keys             Keys
23627                 FOV80            uint8
23628                 WantedRange      uint8 // in MapBlks.
23629         }))(obj)).Vel100 {
23630                 {
23631                         p := &((*(*(struct {
23632                                 Pos100, Vel100   [3]int32
23633                                 Pitch100, Yaw100 int32
23634                                 Keys             Keys
23635                                 FOV80            uint8
23636                                 WantedRange      uint8 // in MapBlks.
23637                         }))(obj)).Vel100)[local276]
23638                         *p = int32(read32(r))
23639                 }
23640         }
23641         {
23642                 p := &(*(*(struct {
23643                         Pos100, Vel100   [3]int32
23644                         Pitch100, Yaw100 int32
23645                         Keys             Keys
23646                         FOV80            uint8
23647                         WantedRange      uint8 // in MapBlks.
23648                 }))(obj)).Pitch100
23649                 *p = int32(read32(r))
23650         }
23651         {
23652                 p := &(*(*(struct {
23653                         Pos100, Vel100   [3]int32
23654                         Pitch100, Yaw100 int32
23655                         Keys             Keys
23656                         FOV80            uint8
23657                         WantedRange      uint8 // in MapBlks.
23658                 }))(obj)).Yaw100
23659                 *p = int32(read32(r))
23660         }
23661         if err := pcall(func() {
23662                 ((*(*(struct {
23663                         Pos100, Vel100   [3]int32
23664                         Pitch100, Yaw100 int32
23665                         Keys             Keys
23666                         FOV80            uint8
23667                         WantedRange      uint8 // in MapBlks.
23668                 }))(obj)).Keys).deserialize(r)
23669         }); err != nil {
23670                 if err == io.EOF {
23671                         chk(io.EOF)
23672                 }
23673                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Keys", err))
23674         }
23675         {
23676                 p := &(*(*(struct {
23677                         Pos100, Vel100   [3]int32
23678                         Pitch100, Yaw100 int32
23679                         Keys             Keys
23680                         FOV80            uint8
23681                         WantedRange      uint8 // in MapBlks.
23682                 }))(obj)).FOV80
23683                 *p = read8(r)
23684         }
23685         {
23686                 p := &(*(*(struct {
23687                         Pos100, Vel100   [3]int32
23688                         Pitch100, Yaw100 int32
23689                         Keys             Keys
23690                         FOV80            uint8
23691                         WantedRange      uint8 // in MapBlks.
23692                 }))(obj)).WantedRange
23693                 *p = read8(r)
23694         }
23695 }
23696
23697 func (obj *Interaction) serialize(w io.Writer) {
23698         {
23699                 x := *(*(uint8))(obj)
23700                 write8(w, uint8(x))
23701         }
23702 }
23703
23704 func (obj *Interaction) deserialize(r io.Reader) {
23705         {
23706                 p := &*(*(uint8))(obj)
23707                 *p = read8(r)
23708         }
23709 }
23710
23711 func (obj *SoundID) serialize(w io.Writer) {
23712         {
23713                 x := *(*(int32))(obj)
23714                 write32(w, uint32(x))
23715         }
23716 }
23717
23718 func (obj *SoundID) deserialize(r io.Reader) {
23719         {
23720                 p := &*(*(int32))(obj)
23721                 *p = int32(read32(r))
23722         }
23723 }
23724
23725 func (obj *Field) serialize(w io.Writer) {
23726         if len(([]byte((*(*(struct {
23727                 Name string
23728
23729                 //mt:len32
23730                 Value string
23731         }))(obj)).Name))) > math.MaxUint16 {
23732                 chk(ErrTooLong)
23733         }
23734         {
23735                 x := uint16(len(([]byte((*(*(struct {
23736                         Name string
23737
23738                         //mt:len32
23739                         Value string
23740                 }))(obj)).Name))))
23741                 write16(w, uint16(x))
23742         }
23743         {
23744                 _, err := w.Write(([]byte((*(*(struct {
23745                         Name string
23746
23747                         //mt:len32
23748                         Value string
23749                 }))(obj)).Name))[:])
23750                 chk(err)
23751         }
23752         if len(([]byte((*(*(struct {
23753                 Name string
23754
23755                 //mt:len32
23756                 Value string
23757         }))(obj)).Value))) > math.MaxUint32 {
23758                 chk(ErrTooLong)
23759         }
23760         {
23761                 x := uint32(len(([]byte((*(*(struct {
23762                         Name string
23763
23764                         //mt:len32
23765                         Value string
23766                 }))(obj)).Value))))
23767                 write32(w, uint32(x))
23768         }
23769         {
23770                 _, err := w.Write(([]byte((*(*(struct {
23771                         Name string
23772
23773                         //mt:len32
23774                         Value string
23775                 }))(obj)).Value))[:])
23776                 chk(err)
23777         }
23778 }
23779
23780 func (obj *Field) deserialize(r io.Reader) {
23781         var local277 []uint8
23782         var local278 uint16
23783         {
23784                 p := &local278
23785                 *p = read16(r)
23786         }
23787         (local277) = make([]uint8, local278)
23788         {
23789                 _, err := io.ReadFull(r, (local277)[:])
23790                 chk(err)
23791         }
23792         ((*(*(struct {
23793                 Name string
23794
23795                 //mt:len32
23796                 Value string
23797         }))(obj)).Name) = string(local277)
23798         var local279 []uint8
23799         var local280 uint32
23800         {
23801                 p := &local280
23802                 *p = read32(r)
23803         }
23804         (local279) = make([]uint8, local280)
23805         {
23806                 _, err := io.ReadFull(r, (local279)[:])
23807                 chk(err)
23808         }
23809         ((*(*(struct {
23810                 Name string
23811
23812                 //mt:len32
23813                 Value string
23814         }))(obj)).Value) = string(local279)
23815 }
23816
23817 func (obj *AuthMethods) serialize(w io.Writer) {
23818         {
23819                 x := *(*(uint32))(obj)
23820                 write32(w, uint32(x))
23821         }
23822 }
23823
23824 func (obj *AuthMethods) deserialize(r io.Reader) {
23825         {
23826                 p := &*(*(uint32))(obj)
23827                 *p = read32(r)
23828         }
23829 }
23830
23831 func (obj *Pos) serialize(w io.Writer) {
23832         if err := pcall(func() {
23833                 (*(*(Vec))(obj)).serialize(w)
23834         }); err != nil {
23835                 if err == io.EOF {
23836                         chk(io.EOF)
23837                 }
23838                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
23839         }
23840 }
23841
23842 func (obj *Pos) deserialize(r io.Reader) {
23843         if err := pcall(func() {
23844                 (*(*(Vec))(obj)).deserialize(r)
23845         }); err != nil {
23846                 if err == io.EOF {
23847                         chk(io.EOF)
23848                 }
23849                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
23850         }
23851 }
23852
23853 func (obj *KickReason) serialize(w io.Writer) {
23854         {
23855                 x := *(*(uint8))(obj)
23856                 write8(w, uint8(x))
23857         }
23858 }
23859
23860 func (obj *KickReason) deserialize(r io.Reader) {
23861         {
23862                 p := &*(*(uint8))(obj)
23863                 *p = read8(r)
23864         }
23865 }
23866
23867 func (obj *MapBlk) serialize(w io.Writer) {
23868         if err := pcall(func() {
23869                 ((*(*(struct {
23870                         Flags   MapBlkFlags
23871                         LitFrom LitFromBlks
23872
23873                         Param0 [4096]Content
23874                         Param1 [4096]uint8
23875                         Param2 [4096]uint8
23876
23877                         NodeMetas map[uint16]*NodeMeta
23878                 }))(obj)).Flags).serialize(w)
23879         }); err != nil {
23880                 if err == io.EOF {
23881                         chk(io.EOF)
23882                 }
23883                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlkFlags", err))
23884         }
23885         if err := pcall(func() {
23886                 ((*(*(struct {
23887                         Flags   MapBlkFlags
23888                         LitFrom LitFromBlks
23889
23890                         Param0 [4096]Content
23891                         Param1 [4096]uint8
23892                         Param2 [4096]uint8
23893
23894                         NodeMetas map[uint16]*NodeMeta
23895                 }))(obj)).LitFrom).serialize(w)
23896         }); err != nil {
23897                 if err == io.EOF {
23898                         chk(io.EOF)
23899                 }
23900                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LitFromBlks", err))
23901         }
23902         {
23903                 local281 := uint8(2) // Size of param0 in bytes.
23904                 {
23905                         x := local281
23906                         write8(w, uint8(x))
23907                 }
23908         }
23909         {
23910                 local282 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23911                 {
23912                         x := local282
23913                         write8(w, uint8(x))
23914                 }
23915         }
23916         for local283 := range (*(*(struct {
23917                 Flags   MapBlkFlags
23918                 LitFrom LitFromBlks
23919
23920                 Param0 [4096]Content
23921                 Param1 [4096]uint8
23922                 Param2 [4096]uint8
23923
23924                 NodeMetas map[uint16]*NodeMeta
23925         }))(obj)).Param0 {
23926                 if err := pcall(func() {
23927                         (((*(*(struct {
23928                                 Flags   MapBlkFlags
23929                                 LitFrom LitFromBlks
23930
23931                                 Param0 [4096]Content
23932                                 Param1 [4096]uint8
23933                                 Param2 [4096]uint8
23934
23935                                 NodeMetas map[uint16]*NodeMeta
23936                         }))(obj)).Param0)[local283]).serialize(w)
23937                 }); err != nil {
23938                         if err == io.EOF {
23939                                 chk(io.EOF)
23940                         }
23941                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
23942                 }
23943         }
23944         {
23945                 _, err := w.Write(((*(*(struct {
23946                         Flags   MapBlkFlags
23947                         LitFrom LitFromBlks
23948
23949                         Param0 [4096]Content
23950                         Param1 [4096]uint8
23951                         Param2 [4096]uint8
23952
23953                         NodeMetas map[uint16]*NodeMeta
23954                 }))(obj)).Param1)[:])
23955                 chk(err)
23956         }
23957         {
23958                 _, err := w.Write(((*(*(struct {
23959                         Flags   MapBlkFlags
23960                         LitFrom LitFromBlks
23961
23962                         Param0 [4096]Content
23963                         Param1 [4096]uint8
23964                         Param2 [4096]uint8
23965
23966                         NodeMetas map[uint16]*NodeMeta
23967                 }))(obj)).Param2)[:])
23968                 chk(err)
23969         }
23970         {
23971                 x := (*(*(struct {
23972                         Flags   MapBlkFlags
23973                         LitFrom LitFromBlks
23974
23975                         Param0 [4096]Content
23976                         Param1 [4096]uint8
23977                         Param2 [4096]uint8
23978
23979                         NodeMetas map[uint16]*NodeMeta
23980                 }))(obj)).NodeMetas
23981                 {
23982                         if x == nil {
23983                                 write8(w, 0)
23984                         } else {
23985                                 write8(w, 2)
23986                                 // len(map[uint16]...) always < math.MaxUint16
23987                                 write16(w, uint16(len(x)))
23988                                 keys := make([]uint16, 0, len(x))
23989                                 for key := range x {
23990                                         keys = append(keys, key)
23991                                 }
23992                                 sort.Slice(keys, func(i, j int) bool {
23993                                         i2pos := func(i int) [3]int16 {
23994                                                 return Blkpos2Pos([3]int16{}, keys[i])
23995                                         }
23996                                         p, q := i2pos(i), i2pos(j)
23997                                         for i := range p {
23998                                                 switch {
23999                                                 case p[i] < q[i]:
24000                                                         return true
24001                                                 case p[i] > q[i]:
24002                                                         return false
24003                                                 }
24004                                         }
24005                                         return false
24006                                 })
24007                                 for _, key := range keys {
24008                                         write16(w, key)
24009                                         chk(serialize(w, x[key]))
24010                                 }
24011                         }
24012                 }
24013         }
24014 }
24015
24016 func (obj *MapBlk) deserialize(r io.Reader) {
24017         if err := pcall(func() {
24018                 ((*(*(struct {
24019                         Flags   MapBlkFlags
24020                         LitFrom LitFromBlks
24021
24022                         Param0 [4096]Content
24023                         Param1 [4096]uint8
24024                         Param2 [4096]uint8
24025
24026                         NodeMetas map[uint16]*NodeMeta
24027                 }))(obj)).Flags).deserialize(r)
24028         }); err != nil {
24029                 if err == io.EOF {
24030                         chk(io.EOF)
24031                 }
24032                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlkFlags", err))
24033         }
24034         if err := pcall(func() {
24035                 ((*(*(struct {
24036                         Flags   MapBlkFlags
24037                         LitFrom LitFromBlks
24038
24039                         Param0 [4096]Content
24040                         Param1 [4096]uint8
24041                         Param2 [4096]uint8
24042
24043                         NodeMetas map[uint16]*NodeMeta
24044                 }))(obj)).LitFrom).deserialize(r)
24045         }); err != nil {
24046                 if err == io.EOF {
24047                         chk(io.EOF)
24048                 }
24049                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LitFromBlks", err))
24050         }
24051         {
24052                 var local284 uint8
24053                 local285 := uint8(2) // Size of param0 in bytes.
24054                 {
24055                         p := &local284
24056                         *p = read8(r)
24057                 }
24058                 if local284 != local285 {
24059                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local284))
24060                 }
24061         }
24062         {
24063                 var local286 uint8
24064                 local287 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
24065                 {
24066                         p := &local286
24067                         *p = read8(r)
24068                 }
24069                 if local286 != local287 {
24070                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local286))
24071                 }
24072         }
24073         for local288 := range (*(*(struct {
24074                 Flags   MapBlkFlags
24075                 LitFrom LitFromBlks
24076
24077                 Param0 [4096]Content
24078                 Param1 [4096]uint8
24079                 Param2 [4096]uint8
24080
24081                 NodeMetas map[uint16]*NodeMeta
24082         }))(obj)).Param0 {
24083                 if err := pcall(func() {
24084                         (((*(*(struct {
24085                                 Flags   MapBlkFlags
24086                                 LitFrom LitFromBlks
24087
24088                                 Param0 [4096]Content
24089                                 Param1 [4096]uint8
24090                                 Param2 [4096]uint8
24091
24092                                 NodeMetas map[uint16]*NodeMeta
24093                         }))(obj)).Param0)[local288]).deserialize(r)
24094                 }); err != nil {
24095                         if err == io.EOF {
24096                                 chk(io.EOF)
24097                         }
24098                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24099                 }
24100         }
24101         {
24102                 _, err := io.ReadFull(r, ((*(*(struct {
24103                         Flags   MapBlkFlags
24104                         LitFrom LitFromBlks
24105
24106                         Param0 [4096]Content
24107                         Param1 [4096]uint8
24108                         Param2 [4096]uint8
24109
24110                         NodeMetas map[uint16]*NodeMeta
24111                 }))(obj)).Param1)[:])
24112                 chk(err)
24113         }
24114         {
24115                 _, err := io.ReadFull(r, ((*(*(struct {
24116                         Flags   MapBlkFlags
24117                         LitFrom LitFromBlks
24118
24119                         Param0 [4096]Content
24120                         Param1 [4096]uint8
24121                         Param2 [4096]uint8
24122
24123                         NodeMetas map[uint16]*NodeMeta
24124                 }))(obj)).Param2)[:])
24125                 chk(err)
24126         }
24127         {
24128                 p := &(*(*(struct {
24129                         Flags   MapBlkFlags
24130                         LitFrom LitFromBlks
24131
24132                         Param0 [4096]Content
24133                         Param1 [4096]uint8
24134                         Param2 [4096]uint8
24135
24136                         NodeMetas map[uint16]*NodeMeta
24137                 }))(obj)).NodeMetas
24138                 {
24139                         switch ver := read8(r); ver {
24140                         case 0:
24141                                 *p = nil
24142                         case 2:
24143                                 n := read16(r)
24144                                 *p = make(map[uint16]*NodeMeta, n)
24145                                 for ; n > 0; n-- {
24146                                         pos := read16(r)
24147                                         nm := new(NodeMeta)
24148                                         chk(deserialize(r, nm))
24149                                         (*p)[pos] = nm
24150                                 }
24151                         default:
24152                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
24153                         }
24154                 }
24155         }
24156 }
24157
24158 func (obj *Node) serialize(w io.Writer) {
24159         if err := pcall(func() {
24160                 ((*(*(struct {
24161                         Param0         Content
24162                         Param1, Param2 uint8
24163                 }))(obj)).Param0).serialize(w)
24164         }); err != nil {
24165                 if err == io.EOF {
24166                         chk(io.EOF)
24167                 }
24168                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24169         }
24170         {
24171                 x := (*(*(struct {
24172                         Param0         Content
24173                         Param1, Param2 uint8
24174                 }))(obj)).Param1
24175                 write8(w, uint8(x))
24176         }
24177         {
24178                 x := (*(*(struct {
24179                         Param0         Content
24180                         Param1, Param2 uint8
24181                 }))(obj)).Param2
24182                 write8(w, uint8(x))
24183         }
24184 }
24185
24186 func (obj *Node) deserialize(r io.Reader) {
24187         if err := pcall(func() {
24188                 ((*(*(struct {
24189                         Param0         Content
24190                         Param1, Param2 uint8
24191                 }))(obj)).Param0).deserialize(r)
24192         }); err != nil {
24193                 if err == io.EOF {
24194                         chk(io.EOF)
24195                 }
24196                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24197         }
24198         {
24199                 p := &(*(*(struct {
24200                         Param0         Content
24201                         Param1, Param2 uint8
24202                 }))(obj)).Param1
24203                 *p = read8(r)
24204         }
24205         {
24206                 p := &(*(*(struct {
24207                         Param0         Content
24208                         Param1, Param2 uint8
24209                 }))(obj)).Param2
24210                 *p = read8(r)
24211         }
24212 }
24213
24214 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
24215         {
24216                 x := *(*(uint64))(obj)
24217                 write64(w, uint64(x))
24218         }
24219 }
24220
24221 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
24222         {
24223                 p := &*(*(uint64))(obj)
24224                 *p = read64(r)
24225         }
24226 }
24227
24228 func (obj *Vec) serialize(w io.Writer) {
24229         for local289 := range *(*([3]float32))(obj) {
24230                 {
24231                         x := (*(*([3]float32))(obj))[local289]
24232                         write32(w, math.Float32bits(x))
24233                 }
24234         }
24235 }
24236
24237 func (obj *Vec) deserialize(r io.Reader) {
24238         for local290 := range *(*([3]float32))(obj) {
24239                 {
24240                         p := &(*(*([3]float32))(obj))[local290]
24241                         *p = math.Float32frombits(read32(r))
24242                 }
24243         }
24244 }
24245
24246 func (obj *ChatMsgType) serialize(w io.Writer) {
24247         {
24248                 x := *(*(uint8))(obj)
24249                 write8(w, uint8(x))
24250         }
24251 }
24252
24253 func (obj *ChatMsgType) deserialize(r io.Reader) {
24254         {
24255                 p := &*(*(uint8))(obj)
24256                 *p = read8(r)
24257         }
24258 }
24259
24260 func (obj *AOID) serialize(w io.Writer) {
24261         {
24262                 x := *(*(uint16))(obj)
24263                 write16(w, uint16(x))
24264         }
24265 }
24266
24267 func (obj *AOID) deserialize(r io.Reader) {
24268         {
24269                 p := &*(*(uint16))(obj)
24270                 *p = read16(r)
24271         }
24272 }
24273
24274 func (obj *AOAdd) serialize(w io.Writer) {
24275         if err := pcall(func() {
24276                 ((*(*(struct {
24277                         ID AOID
24278                         //mt:const genericCAO
24279                         //mt:lenhdr 32
24280                         InitData AOInitData
24281                 }))(obj)).ID).serialize(w)
24282         }); err != nil {
24283                 if err == io.EOF {
24284                         chk(io.EOF)
24285                 }
24286                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24287         }
24288         {
24289                 local291 := genericCAO
24290                 if err := pcall(func() {
24291                         (local291).serialize(w)
24292                 }); err != nil {
24293                         if err == io.EOF {
24294                                 chk(io.EOF)
24295                         }
24296                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
24297                 }
24298         }
24299         {
24300                 ow := w
24301                 w := new(bytes.Buffer)
24302                 if err := pcall(func() {
24303                         ((*(*(struct {
24304                                 ID AOID
24305                                 //mt:const genericCAO
24306                                 //mt:lenhdr 32
24307                                 InitData AOInitData
24308                         }))(obj)).InitData).serialize(w)
24309                 }); err != nil {
24310                         if err == io.EOF {
24311                                 chk(io.EOF)
24312                         }
24313                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOInitData", err))
24314                 }
24315                 {
24316                         buf := w
24317                         w := ow
24318                         if len((buf.Bytes())) > math.MaxUint32 {
24319                                 chk(ErrTooLong)
24320                         }
24321                         {
24322                                 x := uint32(len((buf.Bytes())))
24323                                 write32(w, uint32(x))
24324                         }
24325                         {
24326                                 _, err := w.Write((buf.Bytes())[:])
24327                                 chk(err)
24328                         }
24329                 }
24330         }
24331 }
24332
24333 func (obj *AOAdd) deserialize(r io.Reader) {
24334         if err := pcall(func() {
24335                 ((*(*(struct {
24336                         ID AOID
24337                         //mt:const genericCAO
24338                         //mt:lenhdr 32
24339                         InitData AOInitData
24340                 }))(obj)).ID).deserialize(r)
24341         }); err != nil {
24342                 if err == io.EOF {
24343                         chk(io.EOF)
24344                 }
24345                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24346         }
24347         {
24348                 var local292 aoType
24349                 local293 := genericCAO
24350                 if err := pcall(func() {
24351                         (local292).deserialize(r)
24352                 }); err != nil {
24353                         if err == io.EOF {
24354                                 chk(io.EOF)
24355                         }
24356                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
24357                 }
24358                 if local292 != local293 {
24359                         chk(fmt.Errorf("const %v: %v", "genericCAO", local292))
24360                 }
24361         }
24362         {
24363                 var n uint32
24364                 {
24365                         p := &n
24366                         *p = read32(r)
24367                 }
24368                 r := &io.LimitedReader{R: r, N: int64(n)}
24369                 if err := pcall(func() {
24370                         ((*(*(struct {
24371                                 ID AOID
24372                                 //mt:const genericCAO
24373                                 //mt:lenhdr 32
24374                                 InitData AOInitData
24375                         }))(obj)).InitData).deserialize(r)
24376                 }); err != nil {
24377                         if err == io.EOF {
24378                                 chk(io.EOF)
24379                         }
24380                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOInitData", err))
24381                 }
24382                 if r.N > 0 {
24383                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
24384                 }
24385         }
24386 }
24387
24388 func (obj *IDAOMsg) serialize(w io.Writer) {
24389         if err := pcall(func() {
24390                 ((*(*(struct {
24391                         ID AOID
24392                         //mt:lenhdr 16
24393                         Msg AOMsg
24394                 }))(obj)).ID).serialize(w)
24395         }); err != nil {
24396                 if err == io.EOF {
24397                         chk(io.EOF)
24398                 }
24399                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24400         }
24401         {
24402                 ow := w
24403                 w := new(bytes.Buffer)
24404                 {
24405                         x := (*(*(struct {
24406                                 ID AOID
24407                                 //mt:lenhdr 16
24408                                 Msg AOMsg
24409                         }))(obj)).Msg
24410                         writeAOMsg(w, x)
24411                 }
24412                 {
24413                         buf := w
24414                         w := ow
24415                         if len((buf.Bytes())) > math.MaxUint16 {
24416                                 chk(ErrTooLong)
24417                         }
24418                         {
24419                                 x := uint16(len((buf.Bytes())))
24420                                 write16(w, uint16(x))
24421                         }
24422                         {
24423                                 _, err := w.Write((buf.Bytes())[:])
24424                                 chk(err)
24425                         }
24426                 }
24427         }
24428 }
24429
24430 func (obj *IDAOMsg) deserialize(r io.Reader) {
24431         if err := pcall(func() {
24432                 ((*(*(struct {
24433                         ID AOID
24434                         //mt:lenhdr 16
24435                         Msg AOMsg
24436                 }))(obj)).ID).deserialize(r)
24437         }); err != nil {
24438                 if err == io.EOF {
24439                         chk(io.EOF)
24440                 }
24441                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24442         }
24443         {
24444                 var n uint16
24445                 {
24446                         p := &n
24447                         *p = read16(r)
24448                 }
24449                 r := &io.LimitedReader{R: r, N: int64(n)}
24450                 {
24451                         p := &(*(*(struct {
24452                                 ID AOID
24453                                 //mt:lenhdr 16
24454                                 Msg AOMsg
24455                         }))(obj)).Msg
24456                         {
24457                                 var err error
24458                                 *p, err = readAOMsg(r)
24459                                 chk(err)
24460                         }
24461                 }
24462                 if r.N > 0 {
24463                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
24464                 }
24465         }
24466 }
24467
24468 func (obj *ItemDef) serialize(w io.Writer) {
24469         {
24470                 ow := w
24471                 w := new(bytes.Buffer)
24472                 {
24473                         local294 := uint8(6)
24474                         {
24475                                 x := local294
24476                                 write8(w, uint8(x))
24477                         }
24478                 }
24479                 if err := pcall(func() {
24480                         ((*(*(struct {
24481                                 Type ItemType
24482
24483                                 Name, Desc string
24484
24485                                 InvImg, WieldImg Texture
24486                                 WieldScale       [3]float32
24487
24488                                 StackMax uint16
24489
24490                                 Usable          bool
24491                                 CanPointLiquids bool
24492
24493                                 ToolCaps ToolCaps
24494
24495                                 Groups []Group
24496
24497                                 PlacePredict string
24498
24499                                 PlaceSnd, PlaceFailSnd SoundDef
24500
24501                                 PointRange float32
24502
24503                                 // Set index in Palette with "palette_index" item meta field,
24504                                 // this overrides Color.
24505                                 Palette Texture
24506                                 Color   color.NRGBA
24507
24508                                 // Texture overlays.
24509                                 InvOverlay, WieldOverlay Texture
24510
24511                                 ShortDesc string
24512
24513                                 PlaceParam2 uint8
24514                         }))(obj)).Type).serialize(w)
24515                 }); err != nil {
24516                         if err == io.EOF {
24517                                 chk(io.EOF)
24518                         }
24519                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemType", err))
24520                 }
24521                 if len(([]byte((*(*(struct {
24522                         Type ItemType
24523
24524                         Name, Desc string
24525
24526                         InvImg, WieldImg Texture
24527                         WieldScale       [3]float32
24528
24529                         StackMax uint16
24530
24531                         Usable          bool
24532                         CanPointLiquids bool
24533
24534                         ToolCaps ToolCaps
24535
24536                         Groups []Group
24537
24538                         PlacePredict string
24539
24540                         PlaceSnd, PlaceFailSnd SoundDef
24541
24542                         PointRange float32
24543
24544                         // Set index in Palette with "palette_index" item meta field,
24545                         // this overrides Color.
24546                         Palette Texture
24547                         Color   color.NRGBA
24548
24549                         // Texture overlays.
24550                         InvOverlay, WieldOverlay Texture
24551
24552                         ShortDesc string
24553
24554                         PlaceParam2 uint8
24555                 }))(obj)).Name))) > math.MaxUint16 {
24556                         chk(ErrTooLong)
24557                 }
24558                 {
24559                         x := uint16(len(([]byte((*(*(struct {
24560                                 Type ItemType
24561
24562                                 Name, Desc string
24563
24564                                 InvImg, WieldImg Texture
24565                                 WieldScale       [3]float32
24566
24567                                 StackMax uint16
24568
24569                                 Usable          bool
24570                                 CanPointLiquids bool
24571
24572                                 ToolCaps ToolCaps
24573
24574                                 Groups []Group
24575
24576                                 PlacePredict string
24577
24578                                 PlaceSnd, PlaceFailSnd SoundDef
24579
24580                                 PointRange float32
24581
24582                                 // Set index in Palette with "palette_index" item meta field,
24583                                 // this overrides Color.
24584                                 Palette Texture
24585                                 Color   color.NRGBA
24586
24587                                 // Texture overlays.
24588                                 InvOverlay, WieldOverlay Texture
24589
24590                                 ShortDesc string
24591
24592                                 PlaceParam2 uint8
24593                         }))(obj)).Name))))
24594                         write16(w, uint16(x))
24595                 }
24596                 {
24597                         _, err := w.Write(([]byte((*(*(struct {
24598                                 Type ItemType
24599
24600                                 Name, Desc string
24601
24602                                 InvImg, WieldImg Texture
24603                                 WieldScale       [3]float32
24604
24605                                 StackMax uint16
24606
24607                                 Usable          bool
24608                                 CanPointLiquids bool
24609
24610                                 ToolCaps ToolCaps
24611
24612                                 Groups []Group
24613
24614                                 PlacePredict string
24615
24616                                 PlaceSnd, PlaceFailSnd SoundDef
24617
24618                                 PointRange float32
24619
24620                                 // Set index in Palette with "palette_index" item meta field,
24621                                 // this overrides Color.
24622                                 Palette Texture
24623                                 Color   color.NRGBA
24624
24625                                 // Texture overlays.
24626                                 InvOverlay, WieldOverlay Texture
24627
24628                                 ShortDesc string
24629
24630                                 PlaceParam2 uint8
24631                         }))(obj)).Name))[:])
24632                         chk(err)
24633                 }
24634                 if len(([]byte((*(*(struct {
24635                         Type ItemType
24636
24637                         Name, Desc string
24638
24639                         InvImg, WieldImg Texture
24640                         WieldScale       [3]float32
24641
24642                         StackMax uint16
24643
24644                         Usable          bool
24645                         CanPointLiquids bool
24646
24647                         ToolCaps ToolCaps
24648
24649                         Groups []Group
24650
24651                         PlacePredict string
24652
24653                         PlaceSnd, PlaceFailSnd SoundDef
24654
24655                         PointRange float32
24656
24657                         // Set index in Palette with "palette_index" item meta field,
24658                         // this overrides Color.
24659                         Palette Texture
24660                         Color   color.NRGBA
24661
24662                         // Texture overlays.
24663                         InvOverlay, WieldOverlay Texture
24664
24665                         ShortDesc string
24666
24667                         PlaceParam2 uint8
24668                 }))(obj)).Desc))) > math.MaxUint16 {
24669                         chk(ErrTooLong)
24670                 }
24671                 {
24672                         x := uint16(len(([]byte((*(*(struct {
24673                                 Type ItemType
24674
24675                                 Name, Desc string
24676
24677                                 InvImg, WieldImg Texture
24678                                 WieldScale       [3]float32
24679
24680                                 StackMax uint16
24681
24682                                 Usable          bool
24683                                 CanPointLiquids bool
24684
24685                                 ToolCaps ToolCaps
24686
24687                                 Groups []Group
24688
24689                                 PlacePredict string
24690
24691                                 PlaceSnd, PlaceFailSnd SoundDef
24692
24693                                 PointRange float32
24694
24695                                 // Set index in Palette with "palette_index" item meta field,
24696                                 // this overrides Color.
24697                                 Palette Texture
24698                                 Color   color.NRGBA
24699
24700                                 // Texture overlays.
24701                                 InvOverlay, WieldOverlay Texture
24702
24703                                 ShortDesc string
24704
24705                                 PlaceParam2 uint8
24706                         }))(obj)).Desc))))
24707                         write16(w, uint16(x))
24708                 }
24709                 {
24710                         _, err := w.Write(([]byte((*(*(struct {
24711                                 Type ItemType
24712
24713                                 Name, Desc string
24714
24715                                 InvImg, WieldImg Texture
24716                                 WieldScale       [3]float32
24717
24718                                 StackMax uint16
24719
24720                                 Usable          bool
24721                                 CanPointLiquids bool
24722
24723                                 ToolCaps ToolCaps
24724
24725                                 Groups []Group
24726
24727                                 PlacePredict string
24728
24729                                 PlaceSnd, PlaceFailSnd SoundDef
24730
24731                                 PointRange float32
24732
24733                                 // Set index in Palette with "palette_index" item meta field,
24734                                 // this overrides Color.
24735                                 Palette Texture
24736                                 Color   color.NRGBA
24737
24738                                 // Texture overlays.
24739                                 InvOverlay, WieldOverlay Texture
24740
24741                                 ShortDesc string
24742
24743                                 PlaceParam2 uint8
24744                         }))(obj)).Desc))[:])
24745                         chk(err)
24746                 }
24747                 if err := pcall(func() {
24748                         ((*(*(struct {
24749                                 Type ItemType
24750
24751                                 Name, Desc string
24752
24753                                 InvImg, WieldImg Texture
24754                                 WieldScale       [3]float32
24755
24756                                 StackMax uint16
24757
24758                                 Usable          bool
24759                                 CanPointLiquids bool
24760
24761                                 ToolCaps ToolCaps
24762
24763                                 Groups []Group
24764
24765                                 PlacePredict string
24766
24767                                 PlaceSnd, PlaceFailSnd SoundDef
24768
24769                                 PointRange float32
24770
24771                                 // Set index in Palette with "palette_index" item meta field,
24772                                 // this overrides Color.
24773                                 Palette Texture
24774                                 Color   color.NRGBA
24775
24776                                 // Texture overlays.
24777                                 InvOverlay, WieldOverlay Texture
24778
24779                                 ShortDesc string
24780
24781                                 PlaceParam2 uint8
24782                         }))(obj)).InvImg).serialize(w)
24783                 }); err != nil {
24784                         if err == io.EOF {
24785                                 chk(io.EOF)
24786                         }
24787                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24788                 }
24789                 if err := pcall(func() {
24790                         ((*(*(struct {
24791                                 Type ItemType
24792
24793                                 Name, Desc string
24794
24795                                 InvImg, WieldImg Texture
24796                                 WieldScale       [3]float32
24797
24798                                 StackMax uint16
24799
24800                                 Usable          bool
24801                                 CanPointLiquids bool
24802
24803                                 ToolCaps ToolCaps
24804
24805                                 Groups []Group
24806
24807                                 PlacePredict string
24808
24809                                 PlaceSnd, PlaceFailSnd SoundDef
24810
24811                                 PointRange float32
24812
24813                                 // Set index in Palette with "palette_index" item meta field,
24814                                 // this overrides Color.
24815                                 Palette Texture
24816                                 Color   color.NRGBA
24817
24818                                 // Texture overlays.
24819                                 InvOverlay, WieldOverlay Texture
24820
24821                                 ShortDesc string
24822
24823                                 PlaceParam2 uint8
24824                         }))(obj)).WieldImg).serialize(w)
24825                 }); err != nil {
24826                         if err == io.EOF {
24827                                 chk(io.EOF)
24828                         }
24829                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24830                 }
24831                 for local295 := range (*(*(struct {
24832                         Type ItemType
24833
24834                         Name, Desc string
24835
24836                         InvImg, WieldImg Texture
24837                         WieldScale       [3]float32
24838
24839                         StackMax uint16
24840
24841                         Usable          bool
24842                         CanPointLiquids bool
24843
24844                         ToolCaps ToolCaps
24845
24846                         Groups []Group
24847
24848                         PlacePredict string
24849
24850                         PlaceSnd, PlaceFailSnd SoundDef
24851
24852                         PointRange float32
24853
24854                         // Set index in Palette with "palette_index" item meta field,
24855                         // this overrides Color.
24856                         Palette Texture
24857                         Color   color.NRGBA
24858
24859                         // Texture overlays.
24860                         InvOverlay, WieldOverlay Texture
24861
24862                         ShortDesc string
24863
24864                         PlaceParam2 uint8
24865                 }))(obj)).WieldScale {
24866                         {
24867                                 x := ((*(*(struct {
24868                                         Type ItemType
24869
24870                                         Name, Desc string
24871
24872                                         InvImg, WieldImg Texture
24873                                         WieldScale       [3]float32
24874
24875                                         StackMax uint16
24876
24877                                         Usable          bool
24878                                         CanPointLiquids bool
24879
24880                                         ToolCaps ToolCaps
24881
24882                                         Groups []Group
24883
24884                                         PlacePredict string
24885
24886                                         PlaceSnd, PlaceFailSnd SoundDef
24887
24888                                         PointRange float32
24889
24890                                         // Set index in Palette with "palette_index" item meta field,
24891                                         // this overrides Color.
24892                                         Palette Texture
24893                                         Color   color.NRGBA
24894
24895                                         // Texture overlays.
24896                                         InvOverlay, WieldOverlay Texture
24897
24898                                         ShortDesc string
24899
24900                                         PlaceParam2 uint8
24901                                 }))(obj)).WieldScale)[local295]
24902                                 write32(w, math.Float32bits(x))
24903                         }
24904                 }
24905                 {
24906                         x := (*(*(struct {
24907                                 Type ItemType
24908
24909                                 Name, Desc string
24910
24911                                 InvImg, WieldImg Texture
24912                                 WieldScale       [3]float32
24913
24914                                 StackMax uint16
24915
24916                                 Usable          bool
24917                                 CanPointLiquids bool
24918
24919                                 ToolCaps ToolCaps
24920
24921                                 Groups []Group
24922
24923                                 PlacePredict string
24924
24925                                 PlaceSnd, PlaceFailSnd SoundDef
24926
24927                                 PointRange float32
24928
24929                                 // Set index in Palette with "palette_index" item meta field,
24930                                 // this overrides Color.
24931                                 Palette Texture
24932                                 Color   color.NRGBA
24933
24934                                 // Texture overlays.
24935                                 InvOverlay, WieldOverlay Texture
24936
24937                                 ShortDesc string
24938
24939                                 PlaceParam2 uint8
24940                         }))(obj)).StackMax
24941                         write16(w, uint16(x))
24942                 }
24943                 {
24944                         x := (*(*(struct {
24945                                 Type ItemType
24946
24947                                 Name, Desc string
24948
24949                                 InvImg, WieldImg Texture
24950                                 WieldScale       [3]float32
24951
24952                                 StackMax uint16
24953
24954                                 Usable          bool
24955                                 CanPointLiquids bool
24956
24957                                 ToolCaps ToolCaps
24958
24959                                 Groups []Group
24960
24961                                 PlacePredict string
24962
24963                                 PlaceSnd, PlaceFailSnd SoundDef
24964
24965                                 PointRange float32
24966
24967                                 // Set index in Palette with "palette_index" item meta field,
24968                                 // this overrides Color.
24969                                 Palette Texture
24970                                 Color   color.NRGBA
24971
24972                                 // Texture overlays.
24973                                 InvOverlay, WieldOverlay Texture
24974
24975                                 ShortDesc string
24976
24977                                 PlaceParam2 uint8
24978                         }))(obj)).Usable
24979                         if x {
24980                                 write8(w, 1)
24981                         } else {
24982                                 write8(w, 0)
24983                         }
24984                 }
24985                 {
24986                         x := (*(*(struct {
24987                                 Type ItemType
24988
24989                                 Name, Desc string
24990
24991                                 InvImg, WieldImg Texture
24992                                 WieldScale       [3]float32
24993
24994                                 StackMax uint16
24995
24996                                 Usable          bool
24997                                 CanPointLiquids bool
24998
24999                                 ToolCaps ToolCaps
25000
25001                                 Groups []Group
25002
25003                                 PlacePredict string
25004
25005                                 PlaceSnd, PlaceFailSnd SoundDef
25006
25007                                 PointRange float32
25008
25009                                 // Set index in Palette with "palette_index" item meta field,
25010                                 // this overrides Color.
25011                                 Palette Texture
25012                                 Color   color.NRGBA
25013
25014                                 // Texture overlays.
25015                                 InvOverlay, WieldOverlay Texture
25016
25017                                 ShortDesc string
25018
25019                                 PlaceParam2 uint8
25020                         }))(obj)).CanPointLiquids
25021                         if x {
25022                                 write8(w, 1)
25023                         } else {
25024                                 write8(w, 0)
25025                         }
25026                 }
25027                 if err := pcall(func() {
25028                         ((*(*(struct {
25029                                 Type ItemType
25030
25031                                 Name, Desc string
25032
25033                                 InvImg, WieldImg Texture
25034                                 WieldScale       [3]float32
25035
25036                                 StackMax uint16
25037
25038                                 Usable          bool
25039                                 CanPointLiquids bool
25040
25041                                 ToolCaps ToolCaps
25042
25043                                 Groups []Group
25044
25045                                 PlacePredict string
25046
25047                                 PlaceSnd, PlaceFailSnd SoundDef
25048
25049                                 PointRange float32
25050
25051                                 // Set index in Palette with "palette_index" item meta field,
25052                                 // this overrides Color.
25053                                 Palette Texture
25054                                 Color   color.NRGBA
25055
25056                                 // Texture overlays.
25057                                 InvOverlay, WieldOverlay Texture
25058
25059                                 ShortDesc string
25060
25061                                 PlaceParam2 uint8
25062                         }))(obj)).ToolCaps).serialize(w)
25063                 }); err != nil {
25064                         if err == io.EOF {
25065                                 chk(io.EOF)
25066                         }
25067                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolCaps", err))
25068                 }
25069                 if len(((*(*(struct {
25070                         Type ItemType
25071
25072                         Name, Desc string
25073
25074                         InvImg, WieldImg Texture
25075                         WieldScale       [3]float32
25076
25077                         StackMax uint16
25078
25079                         Usable          bool
25080                         CanPointLiquids bool
25081
25082                         ToolCaps ToolCaps
25083
25084                         Groups []Group
25085
25086                         PlacePredict string
25087
25088                         PlaceSnd, PlaceFailSnd SoundDef
25089
25090                         PointRange float32
25091
25092                         // Set index in Palette with "palette_index" item meta field,
25093                         // this overrides Color.
25094                         Palette Texture
25095                         Color   color.NRGBA
25096
25097                         // Texture overlays.
25098                         InvOverlay, WieldOverlay Texture
25099
25100                         ShortDesc string
25101
25102                         PlaceParam2 uint8
25103                 }))(obj)).Groups)) > math.MaxUint16 {
25104                         chk(ErrTooLong)
25105                 }
25106                 {
25107                         x := uint16(len(((*(*(struct {
25108                                 Type ItemType
25109
25110                                 Name, Desc string
25111
25112                                 InvImg, WieldImg Texture
25113                                 WieldScale       [3]float32
25114
25115                                 StackMax uint16
25116
25117                                 Usable          bool
25118                                 CanPointLiquids bool
25119
25120                                 ToolCaps ToolCaps
25121
25122                                 Groups []Group
25123
25124                                 PlacePredict string
25125
25126                                 PlaceSnd, PlaceFailSnd SoundDef
25127
25128                                 PointRange float32
25129
25130                                 // Set index in Palette with "palette_index" item meta field,
25131                                 // this overrides Color.
25132                                 Palette Texture
25133                                 Color   color.NRGBA
25134
25135                                 // Texture overlays.
25136                                 InvOverlay, WieldOverlay Texture
25137
25138                                 ShortDesc string
25139
25140                                 PlaceParam2 uint8
25141                         }))(obj)).Groups)))
25142                         write16(w, uint16(x))
25143                 }
25144                 for local296 := range (*(*(struct {
25145                         Type ItemType
25146
25147                         Name, Desc string
25148
25149                         InvImg, WieldImg Texture
25150                         WieldScale       [3]float32
25151
25152                         StackMax uint16
25153
25154                         Usable          bool
25155                         CanPointLiquids bool
25156
25157                         ToolCaps ToolCaps
25158
25159                         Groups []Group
25160
25161                         PlacePredict string
25162
25163                         PlaceSnd, PlaceFailSnd SoundDef
25164
25165                         PointRange float32
25166
25167                         // Set index in Palette with "palette_index" item meta field,
25168                         // this overrides Color.
25169                         Palette Texture
25170                         Color   color.NRGBA
25171
25172                         // Texture overlays.
25173                         InvOverlay, WieldOverlay Texture
25174
25175                         ShortDesc string
25176
25177                         PlaceParam2 uint8
25178                 }))(obj)).Groups {
25179                         if err := pcall(func() {
25180                                 (((*(*(struct {
25181                                         Type ItemType
25182
25183                                         Name, Desc string
25184
25185                                         InvImg, WieldImg Texture
25186                                         WieldScale       [3]float32
25187
25188                                         StackMax uint16
25189
25190                                         Usable          bool
25191                                         CanPointLiquids bool
25192
25193                                         ToolCaps ToolCaps
25194
25195                                         Groups []Group
25196
25197                                         PlacePredict string
25198
25199                                         PlaceSnd, PlaceFailSnd SoundDef
25200
25201                                         PointRange float32
25202
25203                                         // Set index in Palette with "palette_index" item meta field,
25204                                         // this overrides Color.
25205                                         Palette Texture
25206                                         Color   color.NRGBA
25207
25208                                         // Texture overlays.
25209                                         InvOverlay, WieldOverlay Texture
25210
25211                                         ShortDesc string
25212
25213                                         PlaceParam2 uint8
25214                                 }))(obj)).Groups)[local296]).serialize(w)
25215                         }); err != nil {
25216                                 if err == io.EOF {
25217                                         chk(io.EOF)
25218                                 }
25219                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
25220                         }
25221                 }
25222                 if len(([]byte((*(*(struct {
25223                         Type ItemType
25224
25225                         Name, Desc string
25226
25227                         InvImg, WieldImg Texture
25228                         WieldScale       [3]float32
25229
25230                         StackMax uint16
25231
25232                         Usable          bool
25233                         CanPointLiquids bool
25234
25235                         ToolCaps ToolCaps
25236
25237                         Groups []Group
25238
25239                         PlacePredict string
25240
25241                         PlaceSnd, PlaceFailSnd SoundDef
25242
25243                         PointRange float32
25244
25245                         // Set index in Palette with "palette_index" item meta field,
25246                         // this overrides Color.
25247                         Palette Texture
25248                         Color   color.NRGBA
25249
25250                         // Texture overlays.
25251                         InvOverlay, WieldOverlay Texture
25252
25253                         ShortDesc string
25254
25255                         PlaceParam2 uint8
25256                 }))(obj)).PlacePredict))) > math.MaxUint16 {
25257                         chk(ErrTooLong)
25258                 }
25259                 {
25260                         x := uint16(len(([]byte((*(*(struct {
25261                                 Type ItemType
25262
25263                                 Name, Desc string
25264
25265                                 InvImg, WieldImg Texture
25266                                 WieldScale       [3]float32
25267
25268                                 StackMax uint16
25269
25270                                 Usable          bool
25271                                 CanPointLiquids bool
25272
25273                                 ToolCaps ToolCaps
25274
25275                                 Groups []Group
25276
25277                                 PlacePredict string
25278
25279                                 PlaceSnd, PlaceFailSnd SoundDef
25280
25281                                 PointRange float32
25282
25283                                 // Set index in Palette with "palette_index" item meta field,
25284                                 // this overrides Color.
25285                                 Palette Texture
25286                                 Color   color.NRGBA
25287
25288                                 // Texture overlays.
25289                                 InvOverlay, WieldOverlay Texture
25290
25291                                 ShortDesc string
25292
25293                                 PlaceParam2 uint8
25294                         }))(obj)).PlacePredict))))
25295                         write16(w, uint16(x))
25296                 }
25297                 {
25298                         _, err := w.Write(([]byte((*(*(struct {
25299                                 Type ItemType
25300
25301                                 Name, Desc string
25302
25303                                 InvImg, WieldImg Texture
25304                                 WieldScale       [3]float32
25305
25306                                 StackMax uint16
25307
25308                                 Usable          bool
25309                                 CanPointLiquids bool
25310
25311                                 ToolCaps ToolCaps
25312
25313                                 Groups []Group
25314
25315                                 PlacePredict string
25316
25317                                 PlaceSnd, PlaceFailSnd SoundDef
25318
25319                                 PointRange float32
25320
25321                                 // Set index in Palette with "palette_index" item meta field,
25322                                 // this overrides Color.
25323                                 Palette Texture
25324                                 Color   color.NRGBA
25325
25326                                 // Texture overlays.
25327                                 InvOverlay, WieldOverlay Texture
25328
25329                                 ShortDesc string
25330
25331                                 PlaceParam2 uint8
25332                         }))(obj)).PlacePredict))[:])
25333                         chk(err)
25334                 }
25335                 if err := pcall(func() {
25336                         ((*(*(struct {
25337                                 Type ItemType
25338
25339                                 Name, Desc string
25340
25341                                 InvImg, WieldImg Texture
25342                                 WieldScale       [3]float32
25343
25344                                 StackMax uint16
25345
25346                                 Usable          bool
25347                                 CanPointLiquids bool
25348
25349                                 ToolCaps ToolCaps
25350
25351                                 Groups []Group
25352
25353                                 PlacePredict string
25354
25355                                 PlaceSnd, PlaceFailSnd SoundDef
25356
25357                                 PointRange float32
25358
25359                                 // Set index in Palette with "palette_index" item meta field,
25360                                 // this overrides Color.
25361                                 Palette Texture
25362                                 Color   color.NRGBA
25363
25364                                 // Texture overlays.
25365                                 InvOverlay, WieldOverlay Texture
25366
25367                                 ShortDesc string
25368
25369                                 PlaceParam2 uint8
25370                         }))(obj)).PlaceSnd).serialize(w)
25371                 }); err != nil {
25372                         if err == io.EOF {
25373                                 chk(io.EOF)
25374                         }
25375                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
25376                 }
25377                 if err := pcall(func() {
25378                         ((*(*(struct {
25379                                 Type ItemType
25380
25381                                 Name, Desc string
25382
25383                                 InvImg, WieldImg Texture
25384                                 WieldScale       [3]float32
25385
25386                                 StackMax uint16
25387
25388                                 Usable          bool
25389                                 CanPointLiquids bool
25390
25391                                 ToolCaps ToolCaps
25392
25393                                 Groups []Group
25394
25395                                 PlacePredict string
25396
25397                                 PlaceSnd, PlaceFailSnd SoundDef
25398
25399                                 PointRange float32
25400
25401                                 // Set index in Palette with "palette_index" item meta field,
25402                                 // this overrides Color.
25403                                 Palette Texture
25404                                 Color   color.NRGBA
25405
25406                                 // Texture overlays.
25407                                 InvOverlay, WieldOverlay Texture
25408
25409                                 ShortDesc string
25410
25411                                 PlaceParam2 uint8
25412                         }))(obj)).PlaceFailSnd).serialize(w)
25413                 }); err != nil {
25414                         if err == io.EOF {
25415                                 chk(io.EOF)
25416                         }
25417                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
25418                 }
25419                 {
25420                         x := (*(*(struct {
25421                                 Type ItemType
25422
25423                                 Name, Desc string
25424
25425                                 InvImg, WieldImg Texture
25426                                 WieldScale       [3]float32
25427
25428                                 StackMax uint16
25429
25430                                 Usable          bool
25431                                 CanPointLiquids bool
25432
25433                                 ToolCaps ToolCaps
25434
25435                                 Groups []Group
25436
25437                                 PlacePredict string
25438
25439                                 PlaceSnd, PlaceFailSnd SoundDef
25440
25441                                 PointRange float32
25442
25443                                 // Set index in Palette with "palette_index" item meta field,
25444                                 // this overrides Color.
25445                                 Palette Texture
25446                                 Color   color.NRGBA
25447
25448                                 // Texture overlays.
25449                                 InvOverlay, WieldOverlay Texture
25450
25451                                 ShortDesc string
25452
25453                                 PlaceParam2 uint8
25454                         }))(obj)).PointRange
25455                         write32(w, math.Float32bits(x))
25456                 }
25457                 if err := pcall(func() {
25458                         ((*(*(struct {
25459                                 Type ItemType
25460
25461                                 Name, Desc string
25462
25463                                 InvImg, WieldImg Texture
25464                                 WieldScale       [3]float32
25465
25466                                 StackMax uint16
25467
25468                                 Usable          bool
25469                                 CanPointLiquids bool
25470
25471                                 ToolCaps ToolCaps
25472
25473                                 Groups []Group
25474
25475                                 PlacePredict string
25476
25477                                 PlaceSnd, PlaceFailSnd SoundDef
25478
25479                                 PointRange float32
25480
25481                                 // Set index in Palette with "palette_index" item meta field,
25482                                 // this overrides Color.
25483                                 Palette Texture
25484                                 Color   color.NRGBA
25485
25486                                 // Texture overlays.
25487                                 InvOverlay, WieldOverlay Texture
25488
25489                                 ShortDesc string
25490
25491                                 PlaceParam2 uint8
25492                         }))(obj)).Palette).serialize(w)
25493                 }); err != nil {
25494                         if err == io.EOF {
25495                                 chk(io.EOF)
25496                         }
25497                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25498                 }
25499                 {
25500                         x := (*(*(struct {
25501                                 Type ItemType
25502
25503                                 Name, Desc string
25504
25505                                 InvImg, WieldImg Texture
25506                                 WieldScale       [3]float32
25507
25508                                 StackMax uint16
25509
25510                                 Usable          bool
25511                                 CanPointLiquids bool
25512
25513                                 ToolCaps ToolCaps
25514
25515                                 Groups []Group
25516
25517                                 PlacePredict string
25518
25519                                 PlaceSnd, PlaceFailSnd SoundDef
25520
25521                                 PointRange float32
25522
25523                                 // Set index in Palette with "palette_index" item meta field,
25524                                 // this overrides Color.
25525                                 Palette Texture
25526                                 Color   color.NRGBA
25527
25528                                 // Texture overlays.
25529                                 InvOverlay, WieldOverlay Texture
25530
25531                                 ShortDesc string
25532
25533                                 PlaceParam2 uint8
25534                         }))(obj)).Color
25535                         w.Write([]byte{x.A, x.R, x.G, x.B})
25536                 }
25537                 if err := pcall(func() {
25538                         ((*(*(struct {
25539                                 Type ItemType
25540
25541                                 Name, Desc string
25542
25543                                 InvImg, WieldImg Texture
25544                                 WieldScale       [3]float32
25545
25546                                 StackMax uint16
25547
25548                                 Usable          bool
25549                                 CanPointLiquids bool
25550
25551                                 ToolCaps ToolCaps
25552
25553                                 Groups []Group
25554
25555                                 PlacePredict string
25556
25557                                 PlaceSnd, PlaceFailSnd SoundDef
25558
25559                                 PointRange float32
25560
25561                                 // Set index in Palette with "palette_index" item meta field,
25562                                 // this overrides Color.
25563                                 Palette Texture
25564                                 Color   color.NRGBA
25565
25566                                 // Texture overlays.
25567                                 InvOverlay, WieldOverlay Texture
25568
25569                                 ShortDesc string
25570
25571                                 PlaceParam2 uint8
25572                         }))(obj)).InvOverlay).serialize(w)
25573                 }); err != nil {
25574                         if err == io.EOF {
25575                                 chk(io.EOF)
25576                         }
25577                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25578                 }
25579                 if err := pcall(func() {
25580                         ((*(*(struct {
25581                                 Type ItemType
25582
25583                                 Name, Desc string
25584
25585                                 InvImg, WieldImg Texture
25586                                 WieldScale       [3]float32
25587
25588                                 StackMax uint16
25589
25590                                 Usable          bool
25591                                 CanPointLiquids bool
25592
25593                                 ToolCaps ToolCaps
25594
25595                                 Groups []Group
25596
25597                                 PlacePredict string
25598
25599                                 PlaceSnd, PlaceFailSnd SoundDef
25600
25601                                 PointRange float32
25602
25603                                 // Set index in Palette with "palette_index" item meta field,
25604                                 // this overrides Color.
25605                                 Palette Texture
25606                                 Color   color.NRGBA
25607
25608                                 // Texture overlays.
25609                                 InvOverlay, WieldOverlay Texture
25610
25611                                 ShortDesc string
25612
25613                                 PlaceParam2 uint8
25614                         }))(obj)).WieldOverlay).serialize(w)
25615                 }); err != nil {
25616                         if err == io.EOF {
25617                                 chk(io.EOF)
25618                         }
25619                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25620                 }
25621                 if len(([]byte((*(*(struct {
25622                         Type ItemType
25623
25624                         Name, Desc string
25625
25626                         InvImg, WieldImg Texture
25627                         WieldScale       [3]float32
25628
25629                         StackMax uint16
25630
25631                         Usable          bool
25632                         CanPointLiquids bool
25633
25634                         ToolCaps ToolCaps
25635
25636                         Groups []Group
25637
25638                         PlacePredict string
25639
25640                         PlaceSnd, PlaceFailSnd SoundDef
25641
25642                         PointRange float32
25643
25644                         // Set index in Palette with "palette_index" item meta field,
25645                         // this overrides Color.
25646                         Palette Texture
25647                         Color   color.NRGBA
25648
25649                         // Texture overlays.
25650                         InvOverlay, WieldOverlay Texture
25651
25652                         ShortDesc string
25653
25654                         PlaceParam2 uint8
25655                 }))(obj)).ShortDesc))) > math.MaxUint16 {
25656                         chk(ErrTooLong)
25657                 }
25658                 {
25659                         x := uint16(len(([]byte((*(*(struct {
25660                                 Type ItemType
25661
25662                                 Name, Desc string
25663
25664                                 InvImg, WieldImg Texture
25665                                 WieldScale       [3]float32
25666
25667                                 StackMax uint16
25668
25669                                 Usable          bool
25670                                 CanPointLiquids bool
25671
25672                                 ToolCaps ToolCaps
25673
25674                                 Groups []Group
25675
25676                                 PlacePredict string
25677
25678                                 PlaceSnd, PlaceFailSnd SoundDef
25679
25680                                 PointRange float32
25681
25682                                 // Set index in Palette with "palette_index" item meta field,
25683                                 // this overrides Color.
25684                                 Palette Texture
25685                                 Color   color.NRGBA
25686
25687                                 // Texture overlays.
25688                                 InvOverlay, WieldOverlay Texture
25689
25690                                 ShortDesc string
25691
25692                                 PlaceParam2 uint8
25693                         }))(obj)).ShortDesc))))
25694                         write16(w, uint16(x))
25695                 }
25696                 {
25697                         _, err := w.Write(([]byte((*(*(struct {
25698                                 Type ItemType
25699
25700                                 Name, Desc string
25701
25702                                 InvImg, WieldImg Texture
25703                                 WieldScale       [3]float32
25704
25705                                 StackMax uint16
25706
25707                                 Usable          bool
25708                                 CanPointLiquids bool
25709
25710                                 ToolCaps ToolCaps
25711
25712                                 Groups []Group
25713
25714                                 PlacePredict string
25715
25716                                 PlaceSnd, PlaceFailSnd SoundDef
25717
25718                                 PointRange float32
25719
25720                                 // Set index in Palette with "palette_index" item meta field,
25721                                 // this overrides Color.
25722                                 Palette Texture
25723                                 Color   color.NRGBA
25724
25725                                 // Texture overlays.
25726                                 InvOverlay, WieldOverlay Texture
25727
25728                                 ShortDesc string
25729
25730                                 PlaceParam2 uint8
25731                         }))(obj)).ShortDesc))[:])
25732                         chk(err)
25733                 }
25734                 {
25735                         x := (*(*(struct {
25736                                 Type ItemType
25737
25738                                 Name, Desc string
25739
25740                                 InvImg, WieldImg Texture
25741                                 WieldScale       [3]float32
25742
25743                                 StackMax uint16
25744
25745                                 Usable          bool
25746                                 CanPointLiquids bool
25747
25748                                 ToolCaps ToolCaps
25749
25750                                 Groups []Group
25751
25752                                 PlacePredict string
25753
25754                                 PlaceSnd, PlaceFailSnd SoundDef
25755
25756                                 PointRange float32
25757
25758                                 // Set index in Palette with "palette_index" item meta field,
25759                                 // this overrides Color.
25760                                 Palette Texture
25761                                 Color   color.NRGBA
25762
25763                                 // Texture overlays.
25764                                 InvOverlay, WieldOverlay Texture
25765
25766                                 ShortDesc string
25767
25768                                 PlaceParam2 uint8
25769                         }))(obj)).PlaceParam2
25770                         write8(w, uint8(x))
25771                 }
25772                 {
25773                         buf := w
25774                         w := ow
25775                         if len((buf.Bytes())) > math.MaxUint16 {
25776                                 chk(ErrTooLong)
25777                         }
25778                         {
25779                                 x := uint16(len((buf.Bytes())))
25780                                 write16(w, uint16(x))
25781                         }
25782                         {
25783                                 _, err := w.Write((buf.Bytes())[:])
25784                                 chk(err)
25785                         }
25786                 }
25787         }
25788 }
25789
25790 func (obj *ItemDef) deserialize(r io.Reader) {
25791         {
25792                 var n uint16
25793                 {
25794                         p := &n
25795                         *p = read16(r)
25796                 }
25797                 r := &io.LimitedReader{R: r, N: int64(n)}
25798                 {
25799                         var local297 uint8
25800                         local298 := uint8(6)
25801                         {
25802                                 p := &local297
25803                                 *p = read8(r)
25804                         }
25805                         if local297 != local298 {
25806                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local297))
25807                         }
25808                 }
25809                 if err := pcall(func() {
25810                         ((*(*(struct {
25811                                 Type ItemType
25812
25813                                 Name, Desc string
25814
25815                                 InvImg, WieldImg Texture
25816                                 WieldScale       [3]float32
25817
25818                                 StackMax uint16
25819
25820                                 Usable          bool
25821                                 CanPointLiquids bool
25822
25823                                 ToolCaps ToolCaps
25824
25825                                 Groups []Group
25826
25827                                 PlacePredict string
25828
25829                                 PlaceSnd, PlaceFailSnd SoundDef
25830
25831                                 PointRange float32
25832
25833                                 // Set index in Palette with "palette_index" item meta field,
25834                                 // this overrides Color.
25835                                 Palette Texture
25836                                 Color   color.NRGBA
25837
25838                                 // Texture overlays.
25839                                 InvOverlay, WieldOverlay Texture
25840
25841                                 ShortDesc string
25842
25843                                 PlaceParam2 uint8
25844                         }))(obj)).Type).deserialize(r)
25845                 }); err != nil {
25846                         if err == io.EOF {
25847                                 chk(io.EOF)
25848                         }
25849                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemType", err))
25850                 }
25851                 var local299 []uint8
25852                 var local300 uint16
25853                 {
25854                         p := &local300
25855                         *p = read16(r)
25856                 }
25857                 (local299) = make([]uint8, local300)
25858                 {
25859                         _, err := io.ReadFull(r, (local299)[:])
25860                         chk(err)
25861                 }
25862                 ((*(*(struct {
25863                         Type ItemType
25864
25865                         Name, Desc string
25866
25867                         InvImg, WieldImg Texture
25868                         WieldScale       [3]float32
25869
25870                         StackMax uint16
25871
25872                         Usable          bool
25873                         CanPointLiquids bool
25874
25875                         ToolCaps ToolCaps
25876
25877                         Groups []Group
25878
25879                         PlacePredict string
25880
25881                         PlaceSnd, PlaceFailSnd SoundDef
25882
25883                         PointRange float32
25884
25885                         // Set index in Palette with "palette_index" item meta field,
25886                         // this overrides Color.
25887                         Palette Texture
25888                         Color   color.NRGBA
25889
25890                         // Texture overlays.
25891                         InvOverlay, WieldOverlay Texture
25892
25893                         ShortDesc string
25894
25895                         PlaceParam2 uint8
25896                 }))(obj)).Name) = string(local299)
25897                 var local301 []uint8
25898                 var local302 uint16
25899                 {
25900                         p := &local302
25901                         *p = read16(r)
25902                 }
25903                 (local301) = make([]uint8, local302)
25904                 {
25905                         _, err := io.ReadFull(r, (local301)[:])
25906                         chk(err)
25907                 }
25908                 ((*(*(struct {
25909                         Type ItemType
25910
25911                         Name, Desc string
25912
25913                         InvImg, WieldImg Texture
25914                         WieldScale       [3]float32
25915
25916                         StackMax uint16
25917
25918                         Usable          bool
25919                         CanPointLiquids bool
25920
25921                         ToolCaps ToolCaps
25922
25923                         Groups []Group
25924
25925                         PlacePredict string
25926
25927                         PlaceSnd, PlaceFailSnd SoundDef
25928
25929                         PointRange float32
25930
25931                         // Set index in Palette with "palette_index" item meta field,
25932                         // this overrides Color.
25933                         Palette Texture
25934                         Color   color.NRGBA
25935
25936                         // Texture overlays.
25937                         InvOverlay, WieldOverlay Texture
25938
25939                         ShortDesc string
25940
25941                         PlaceParam2 uint8
25942                 }))(obj)).Desc) = string(local301)
25943                 if err := pcall(func() {
25944                         ((*(*(struct {
25945                                 Type ItemType
25946
25947                                 Name, Desc string
25948
25949                                 InvImg, WieldImg Texture
25950                                 WieldScale       [3]float32
25951
25952                                 StackMax uint16
25953
25954                                 Usable          bool
25955                                 CanPointLiquids bool
25956
25957                                 ToolCaps ToolCaps
25958
25959                                 Groups []Group
25960
25961                                 PlacePredict string
25962
25963                                 PlaceSnd, PlaceFailSnd SoundDef
25964
25965                                 PointRange float32
25966
25967                                 // Set index in Palette with "palette_index" item meta field,
25968                                 // this overrides Color.
25969                                 Palette Texture
25970                                 Color   color.NRGBA
25971
25972                                 // Texture overlays.
25973                                 InvOverlay, WieldOverlay Texture
25974
25975                                 ShortDesc string
25976
25977                                 PlaceParam2 uint8
25978                         }))(obj)).InvImg).deserialize(r)
25979                 }); err != nil {
25980                         if err == io.EOF {
25981                                 chk(io.EOF)
25982                         }
25983                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25984                 }
25985                 if err := pcall(func() {
25986                         ((*(*(struct {
25987                                 Type ItemType
25988
25989                                 Name, Desc string
25990
25991                                 InvImg, WieldImg Texture
25992                                 WieldScale       [3]float32
25993
25994                                 StackMax uint16
25995
25996                                 Usable          bool
25997                                 CanPointLiquids bool
25998
25999                                 ToolCaps ToolCaps
26000
26001                                 Groups []Group
26002
26003                                 PlacePredict string
26004
26005                                 PlaceSnd, PlaceFailSnd SoundDef
26006
26007                                 PointRange float32
26008
26009                                 // Set index in Palette with "palette_index" item meta field,
26010                                 // this overrides Color.
26011                                 Palette Texture
26012                                 Color   color.NRGBA
26013
26014                                 // Texture overlays.
26015                                 InvOverlay, WieldOverlay Texture
26016
26017                                 ShortDesc string
26018
26019                                 PlaceParam2 uint8
26020                         }))(obj)).WieldImg).deserialize(r)
26021                 }); err != nil {
26022                         if err == io.EOF {
26023                                 chk(io.EOF)
26024                         }
26025                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26026                 }
26027                 for local303 := range (*(*(struct {
26028                         Type ItemType
26029
26030                         Name, Desc string
26031
26032                         InvImg, WieldImg Texture
26033                         WieldScale       [3]float32
26034
26035                         StackMax uint16
26036
26037                         Usable          bool
26038                         CanPointLiquids bool
26039
26040                         ToolCaps ToolCaps
26041
26042                         Groups []Group
26043
26044                         PlacePredict string
26045
26046                         PlaceSnd, PlaceFailSnd SoundDef
26047
26048                         PointRange float32
26049
26050                         // Set index in Palette with "palette_index" item meta field,
26051                         // this overrides Color.
26052                         Palette Texture
26053                         Color   color.NRGBA
26054
26055                         // Texture overlays.
26056                         InvOverlay, WieldOverlay Texture
26057
26058                         ShortDesc string
26059
26060                         PlaceParam2 uint8
26061                 }))(obj)).WieldScale {
26062                         {
26063                                 p := &((*(*(struct {
26064                                         Type ItemType
26065
26066                                         Name, Desc string
26067
26068                                         InvImg, WieldImg Texture
26069                                         WieldScale       [3]float32
26070
26071                                         StackMax uint16
26072
26073                                         Usable          bool
26074                                         CanPointLiquids bool
26075
26076                                         ToolCaps ToolCaps
26077
26078                                         Groups []Group
26079
26080                                         PlacePredict string
26081
26082                                         PlaceSnd, PlaceFailSnd SoundDef
26083
26084                                         PointRange float32
26085
26086                                         // Set index in Palette with "palette_index" item meta field,
26087                                         // this overrides Color.
26088                                         Palette Texture
26089                                         Color   color.NRGBA
26090
26091                                         // Texture overlays.
26092                                         InvOverlay, WieldOverlay Texture
26093
26094                                         ShortDesc string
26095
26096                                         PlaceParam2 uint8
26097                                 }))(obj)).WieldScale)[local303]
26098                                 *p = math.Float32frombits(read32(r))
26099                         }
26100                 }
26101                 {
26102                         p := &(*(*(struct {
26103                                 Type ItemType
26104
26105                                 Name, Desc string
26106
26107                                 InvImg, WieldImg Texture
26108                                 WieldScale       [3]float32
26109
26110                                 StackMax uint16
26111
26112                                 Usable          bool
26113                                 CanPointLiquids bool
26114
26115                                 ToolCaps ToolCaps
26116
26117                                 Groups []Group
26118
26119                                 PlacePredict string
26120
26121                                 PlaceSnd, PlaceFailSnd SoundDef
26122
26123                                 PointRange float32
26124
26125                                 // Set index in Palette with "palette_index" item meta field,
26126                                 // this overrides Color.
26127                                 Palette Texture
26128                                 Color   color.NRGBA
26129
26130                                 // Texture overlays.
26131                                 InvOverlay, WieldOverlay Texture
26132
26133                                 ShortDesc string
26134
26135                                 PlaceParam2 uint8
26136                         }))(obj)).StackMax
26137                         *p = read16(r)
26138                 }
26139                 {
26140                         p := &(*(*(struct {
26141                                 Type ItemType
26142
26143                                 Name, Desc string
26144
26145                                 InvImg, WieldImg Texture
26146                                 WieldScale       [3]float32
26147
26148                                 StackMax uint16
26149
26150                                 Usable          bool
26151                                 CanPointLiquids bool
26152
26153                                 ToolCaps ToolCaps
26154
26155                                 Groups []Group
26156
26157                                 PlacePredict string
26158
26159                                 PlaceSnd, PlaceFailSnd SoundDef
26160
26161                                 PointRange float32
26162
26163                                 // Set index in Palette with "palette_index" item meta field,
26164                                 // this overrides Color.
26165                                 Palette Texture
26166                                 Color   color.NRGBA
26167
26168                                 // Texture overlays.
26169                                 InvOverlay, WieldOverlay Texture
26170
26171                                 ShortDesc string
26172
26173                                 PlaceParam2 uint8
26174                         }))(obj)).Usable
26175                         switch n := read8(r); n {
26176                         case 0:
26177                                 *p = false
26178                         case 1:
26179                                 *p = true
26180                         default:
26181                                 chk(fmt.Errorf("invalid bool: %d", n))
26182                         }
26183                 }
26184                 {
26185                         p := &(*(*(struct {
26186                                 Type ItemType
26187
26188                                 Name, Desc string
26189
26190                                 InvImg, WieldImg Texture
26191                                 WieldScale       [3]float32
26192
26193                                 StackMax uint16
26194
26195                                 Usable          bool
26196                                 CanPointLiquids bool
26197
26198                                 ToolCaps ToolCaps
26199
26200                                 Groups []Group
26201
26202                                 PlacePredict string
26203
26204                                 PlaceSnd, PlaceFailSnd SoundDef
26205
26206                                 PointRange float32
26207
26208                                 // Set index in Palette with "palette_index" item meta field,
26209                                 // this overrides Color.
26210                                 Palette Texture
26211                                 Color   color.NRGBA
26212
26213                                 // Texture overlays.
26214                                 InvOverlay, WieldOverlay Texture
26215
26216                                 ShortDesc string
26217
26218                                 PlaceParam2 uint8
26219                         }))(obj)).CanPointLiquids
26220                         switch n := read8(r); n {
26221                         case 0:
26222                                 *p = false
26223                         case 1:
26224                                 *p = true
26225                         default:
26226                                 chk(fmt.Errorf("invalid bool: %d", n))
26227                         }
26228                 }
26229                 if err := pcall(func() {
26230                         ((*(*(struct {
26231                                 Type ItemType
26232
26233                                 Name, Desc string
26234
26235                                 InvImg, WieldImg Texture
26236                                 WieldScale       [3]float32
26237
26238                                 StackMax uint16
26239
26240                                 Usable          bool
26241                                 CanPointLiquids bool
26242
26243                                 ToolCaps ToolCaps
26244
26245                                 Groups []Group
26246
26247                                 PlacePredict string
26248
26249                                 PlaceSnd, PlaceFailSnd SoundDef
26250
26251                                 PointRange float32
26252
26253                                 // Set index in Palette with "palette_index" item meta field,
26254                                 // this overrides Color.
26255                                 Palette Texture
26256                                 Color   color.NRGBA
26257
26258                                 // Texture overlays.
26259                                 InvOverlay, WieldOverlay Texture
26260
26261                                 ShortDesc string
26262
26263                                 PlaceParam2 uint8
26264                         }))(obj)).ToolCaps).deserialize(r)
26265                 }); err != nil {
26266                         if err == io.EOF {
26267                                 chk(io.EOF)
26268                         }
26269                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolCaps", err))
26270                 }
26271                 var local304 uint16
26272                 {
26273                         p := &local304
26274                         *p = read16(r)
26275                 }
26276                 ((*(*(struct {
26277                         Type ItemType
26278
26279                         Name, Desc string
26280
26281                         InvImg, WieldImg Texture
26282                         WieldScale       [3]float32
26283
26284                         StackMax uint16
26285
26286                         Usable          bool
26287                         CanPointLiquids bool
26288
26289                         ToolCaps ToolCaps
26290
26291                         Groups []Group
26292
26293                         PlacePredict string
26294
26295                         PlaceSnd, PlaceFailSnd SoundDef
26296
26297                         PointRange float32
26298
26299                         // Set index in Palette with "palette_index" item meta field,
26300                         // this overrides Color.
26301                         Palette Texture
26302                         Color   color.NRGBA
26303
26304                         // Texture overlays.
26305                         InvOverlay, WieldOverlay Texture
26306
26307                         ShortDesc string
26308
26309                         PlaceParam2 uint8
26310                 }))(obj)).Groups) = make([]Group, local304)
26311                 for local305 := range (*(*(struct {
26312                         Type ItemType
26313
26314                         Name, Desc string
26315
26316                         InvImg, WieldImg Texture
26317                         WieldScale       [3]float32
26318
26319                         StackMax uint16
26320
26321                         Usable          bool
26322                         CanPointLiquids bool
26323
26324                         ToolCaps ToolCaps
26325
26326                         Groups []Group
26327
26328                         PlacePredict string
26329
26330                         PlaceSnd, PlaceFailSnd SoundDef
26331
26332                         PointRange float32
26333
26334                         // Set index in Palette with "palette_index" item meta field,
26335                         // this overrides Color.
26336                         Palette Texture
26337                         Color   color.NRGBA
26338
26339                         // Texture overlays.
26340                         InvOverlay, WieldOverlay Texture
26341
26342                         ShortDesc string
26343
26344                         PlaceParam2 uint8
26345                 }))(obj)).Groups {
26346                         if err := pcall(func() {
26347                                 (((*(*(struct {
26348                                         Type ItemType
26349
26350                                         Name, Desc string
26351
26352                                         InvImg, WieldImg Texture
26353                                         WieldScale       [3]float32
26354
26355                                         StackMax uint16
26356
26357                                         Usable          bool
26358                                         CanPointLiquids bool
26359
26360                                         ToolCaps ToolCaps
26361
26362                                         Groups []Group
26363
26364                                         PlacePredict string
26365
26366                                         PlaceSnd, PlaceFailSnd SoundDef
26367
26368                                         PointRange float32
26369
26370                                         // Set index in Palette with "palette_index" item meta field,
26371                                         // this overrides Color.
26372                                         Palette Texture
26373                                         Color   color.NRGBA
26374
26375                                         // Texture overlays.
26376                                         InvOverlay, WieldOverlay Texture
26377
26378                                         ShortDesc string
26379
26380                                         PlaceParam2 uint8
26381                                 }))(obj)).Groups)[local305]).deserialize(r)
26382                         }); err != nil {
26383                                 if err == io.EOF {
26384                                         chk(io.EOF)
26385                                 }
26386                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
26387                         }
26388                 }
26389                 var local306 []uint8
26390                 var local307 uint16
26391                 {
26392                         p := &local307
26393                         *p = read16(r)
26394                 }
26395                 (local306) = make([]uint8, local307)
26396                 {
26397                         _, err := io.ReadFull(r, (local306)[:])
26398                         chk(err)
26399                 }
26400                 ((*(*(struct {
26401                         Type ItemType
26402
26403                         Name, Desc string
26404
26405                         InvImg, WieldImg Texture
26406                         WieldScale       [3]float32
26407
26408                         StackMax uint16
26409
26410                         Usable          bool
26411                         CanPointLiquids bool
26412
26413                         ToolCaps ToolCaps
26414
26415                         Groups []Group
26416
26417                         PlacePredict string
26418
26419                         PlaceSnd, PlaceFailSnd SoundDef
26420
26421                         PointRange float32
26422
26423                         // Set index in Palette with "palette_index" item meta field,
26424                         // this overrides Color.
26425                         Palette Texture
26426                         Color   color.NRGBA
26427
26428                         // Texture overlays.
26429                         InvOverlay, WieldOverlay Texture
26430
26431                         ShortDesc string
26432
26433                         PlaceParam2 uint8
26434                 }))(obj)).PlacePredict) = string(local306)
26435                 if err := pcall(func() {
26436                         ((*(*(struct {
26437                                 Type ItemType
26438
26439                                 Name, Desc string
26440
26441                                 InvImg, WieldImg Texture
26442                                 WieldScale       [3]float32
26443
26444                                 StackMax uint16
26445
26446                                 Usable          bool
26447                                 CanPointLiquids bool
26448
26449                                 ToolCaps ToolCaps
26450
26451                                 Groups []Group
26452
26453                                 PlacePredict string
26454
26455                                 PlaceSnd, PlaceFailSnd SoundDef
26456
26457                                 PointRange float32
26458
26459                                 // Set index in Palette with "palette_index" item meta field,
26460                                 // this overrides Color.
26461                                 Palette Texture
26462                                 Color   color.NRGBA
26463
26464                                 // Texture overlays.
26465                                 InvOverlay, WieldOverlay Texture
26466
26467                                 ShortDesc string
26468
26469                                 PlaceParam2 uint8
26470                         }))(obj)).PlaceSnd).deserialize(r)
26471                 }); err != nil {
26472                         if err == io.EOF {
26473                                 chk(io.EOF)
26474                         }
26475                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
26476                 }
26477                 if err := pcall(func() {
26478                         ((*(*(struct {
26479                                 Type ItemType
26480
26481                                 Name, Desc string
26482
26483                                 InvImg, WieldImg Texture
26484                                 WieldScale       [3]float32
26485
26486                                 StackMax uint16
26487
26488                                 Usable          bool
26489                                 CanPointLiquids bool
26490
26491                                 ToolCaps ToolCaps
26492
26493                                 Groups []Group
26494
26495                                 PlacePredict string
26496
26497                                 PlaceSnd, PlaceFailSnd SoundDef
26498
26499                                 PointRange float32
26500
26501                                 // Set index in Palette with "palette_index" item meta field,
26502                                 // this overrides Color.
26503                                 Palette Texture
26504                                 Color   color.NRGBA
26505
26506                                 // Texture overlays.
26507                                 InvOverlay, WieldOverlay Texture
26508
26509                                 ShortDesc string
26510
26511                                 PlaceParam2 uint8
26512                         }))(obj)).PlaceFailSnd).deserialize(r)
26513                 }); err != nil {
26514                         if err == io.EOF {
26515                                 chk(io.EOF)
26516                         }
26517                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
26518                 }
26519                 {
26520                         p := &(*(*(struct {
26521                                 Type ItemType
26522
26523                                 Name, Desc string
26524
26525                                 InvImg, WieldImg Texture
26526                                 WieldScale       [3]float32
26527
26528                                 StackMax uint16
26529
26530                                 Usable          bool
26531                                 CanPointLiquids bool
26532
26533                                 ToolCaps ToolCaps
26534
26535                                 Groups []Group
26536
26537                                 PlacePredict string
26538
26539                                 PlaceSnd, PlaceFailSnd SoundDef
26540
26541                                 PointRange float32
26542
26543                                 // Set index in Palette with "palette_index" item meta field,
26544                                 // this overrides Color.
26545                                 Palette Texture
26546                                 Color   color.NRGBA
26547
26548                                 // Texture overlays.
26549                                 InvOverlay, WieldOverlay Texture
26550
26551                                 ShortDesc string
26552
26553                                 PlaceParam2 uint8
26554                         }))(obj)).PointRange
26555                         *p = math.Float32frombits(read32(r))
26556                 }
26557                 if err := pcall(func() {
26558                         ((*(*(struct {
26559                                 Type ItemType
26560
26561                                 Name, Desc string
26562
26563                                 InvImg, WieldImg Texture
26564                                 WieldScale       [3]float32
26565
26566                                 StackMax uint16
26567
26568                                 Usable          bool
26569                                 CanPointLiquids bool
26570
26571                                 ToolCaps ToolCaps
26572
26573                                 Groups []Group
26574
26575                                 PlacePredict string
26576
26577                                 PlaceSnd, PlaceFailSnd SoundDef
26578
26579                                 PointRange float32
26580
26581                                 // Set index in Palette with "palette_index" item meta field,
26582                                 // this overrides Color.
26583                                 Palette Texture
26584                                 Color   color.NRGBA
26585
26586                                 // Texture overlays.
26587                                 InvOverlay, WieldOverlay Texture
26588
26589                                 ShortDesc string
26590
26591                                 PlaceParam2 uint8
26592                         }))(obj)).Palette).deserialize(r)
26593                 }); err != nil {
26594                         if err == io.EOF {
26595                                 chk(io.EOF)
26596                         }
26597                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26598                 }
26599                 {
26600                         p := &(*(*(struct {
26601                                 Type ItemType
26602
26603                                 Name, Desc string
26604
26605                                 InvImg, WieldImg Texture
26606                                 WieldScale       [3]float32
26607
26608                                 StackMax uint16
26609
26610                                 Usable          bool
26611                                 CanPointLiquids bool
26612
26613                                 ToolCaps ToolCaps
26614
26615                                 Groups []Group
26616
26617                                 PlacePredict string
26618
26619                                 PlaceSnd, PlaceFailSnd SoundDef
26620
26621                                 PointRange float32
26622
26623                                 // Set index in Palette with "palette_index" item meta field,
26624                                 // this overrides Color.
26625                                 Palette Texture
26626                                 Color   color.NRGBA
26627
26628                                 // Texture overlays.
26629                                 InvOverlay, WieldOverlay Texture
26630
26631                                 ShortDesc string
26632
26633                                 PlaceParam2 uint8
26634                         }))(obj)).Color
26635                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
26636                 }
26637                 if err := pcall(func() {
26638                         ((*(*(struct {
26639                                 Type ItemType
26640
26641                                 Name, Desc string
26642
26643                                 InvImg, WieldImg Texture
26644                                 WieldScale       [3]float32
26645
26646                                 StackMax uint16
26647
26648                                 Usable          bool
26649                                 CanPointLiquids bool
26650
26651                                 ToolCaps ToolCaps
26652
26653                                 Groups []Group
26654
26655                                 PlacePredict string
26656
26657                                 PlaceSnd, PlaceFailSnd SoundDef
26658
26659                                 PointRange float32
26660
26661                                 // Set index in Palette with "palette_index" item meta field,
26662                                 // this overrides Color.
26663                                 Palette Texture
26664                                 Color   color.NRGBA
26665
26666                                 // Texture overlays.
26667                                 InvOverlay, WieldOverlay Texture
26668
26669                                 ShortDesc string
26670
26671                                 PlaceParam2 uint8
26672                         }))(obj)).InvOverlay).deserialize(r)
26673                 }); err != nil {
26674                         if err == io.EOF {
26675                                 chk(io.EOF)
26676                         }
26677                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26678                 }
26679                 if err := pcall(func() {
26680                         ((*(*(struct {
26681                                 Type ItemType
26682
26683                                 Name, Desc string
26684
26685                                 InvImg, WieldImg Texture
26686                                 WieldScale       [3]float32
26687
26688                                 StackMax uint16
26689
26690                                 Usable          bool
26691                                 CanPointLiquids bool
26692
26693                                 ToolCaps ToolCaps
26694
26695                                 Groups []Group
26696
26697                                 PlacePredict string
26698
26699                                 PlaceSnd, PlaceFailSnd SoundDef
26700
26701                                 PointRange float32
26702
26703                                 // Set index in Palette with "palette_index" item meta field,
26704                                 // this overrides Color.
26705                                 Palette Texture
26706                                 Color   color.NRGBA
26707
26708                                 // Texture overlays.
26709                                 InvOverlay, WieldOverlay Texture
26710
26711                                 ShortDesc string
26712
26713                                 PlaceParam2 uint8
26714                         }))(obj)).WieldOverlay).deserialize(r)
26715                 }); err != nil {
26716                         if err == io.EOF {
26717                                 chk(io.EOF)
26718                         }
26719                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26720                 }
26721                 var local308 []uint8
26722                 var local309 uint16
26723                 {
26724                         p := &local309
26725                         *p = read16(r)
26726                 }
26727                 (local308) = make([]uint8, local309)
26728                 {
26729                         _, err := io.ReadFull(r, (local308)[:])
26730                         chk(err)
26731                 }
26732                 ((*(*(struct {
26733                         Type ItemType
26734
26735                         Name, Desc string
26736
26737                         InvImg, WieldImg Texture
26738                         WieldScale       [3]float32
26739
26740                         StackMax uint16
26741
26742                         Usable          bool
26743                         CanPointLiquids bool
26744
26745                         ToolCaps ToolCaps
26746
26747                         Groups []Group
26748
26749                         PlacePredict string
26750
26751                         PlaceSnd, PlaceFailSnd SoundDef
26752
26753                         PointRange float32
26754
26755                         // Set index in Palette with "palette_index" item meta field,
26756                         // this overrides Color.
26757                         Palette Texture
26758                         Color   color.NRGBA
26759
26760                         // Texture overlays.
26761                         InvOverlay, WieldOverlay Texture
26762
26763                         ShortDesc string
26764
26765                         PlaceParam2 uint8
26766                 }))(obj)).ShortDesc) = string(local308)
26767                 {
26768                         p := &(*(*(struct {
26769                                 Type ItemType
26770
26771                                 Name, Desc string
26772
26773                                 InvImg, WieldImg Texture
26774                                 WieldScale       [3]float32
26775
26776                                 StackMax uint16
26777
26778                                 Usable          bool
26779                                 CanPointLiquids bool
26780
26781                                 ToolCaps ToolCaps
26782
26783                                 Groups []Group
26784
26785                                 PlacePredict string
26786
26787                                 PlaceSnd, PlaceFailSnd SoundDef
26788
26789                                 PointRange float32
26790
26791                                 // Set index in Palette with "palette_index" item meta field,
26792                                 // this overrides Color.
26793                                 Palette Texture
26794                                 Color   color.NRGBA
26795
26796                                 // Texture overlays.
26797                                 InvOverlay, WieldOverlay Texture
26798
26799                                 ShortDesc string
26800
26801                                 PlaceParam2 uint8
26802                         }))(obj)).PlaceParam2
26803                         *p = read8(r)
26804                 }
26805                 if r.N > 0 {
26806                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
26807                 }
26808         }
26809 }
26810
26811 func (obj *SoundSrcType) serialize(w io.Writer) {
26812         {
26813                 x := *(*(uint8))(obj)
26814                 write8(w, uint8(x))
26815         }
26816 }
26817
26818 func (obj *SoundSrcType) deserialize(r io.Reader) {
26819         {
26820                 p := &*(*(uint8))(obj)
26821                 *p = read8(r)
26822         }
26823 }
26824
26825 func (obj *TileAnim) serialize(w io.Writer) {
26826         if err := pcall(func() {
26827                 ((*(*(struct {
26828                         Type AnimType
26829
26830                         //mt:if %s.Type == SpriteSheetAnim
26831                         AspectRatio [2]uint8
26832
26833                         //mt:if %s.Type == VerticalFrameAnim
26834                         NFrames [2]uint16
26835
26836                         //mt:if %s.Type != NoAnim
26837                         Duration float32 // in seconds
26838
26839                 }))(obj)).Type).serialize(w)
26840         }); err != nil {
26841                 if err == io.EOF {
26842                         chk(io.EOF)
26843                 }
26844                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AnimType", err))
26845         }
26846         if !((*(*(struct {
26847                 Type AnimType
26848
26849                 //mt:if %s.Type == SpriteSheetAnim
26850                 AspectRatio [2]uint8
26851
26852                 //mt:if %s.Type == VerticalFrameAnim
26853                 NFrames [2]uint16
26854
26855                 //mt:if %s.Type != NoAnim
26856                 Duration float32 // in seconds
26857
26858         }))(obj)).Type < maxAnim) {
26859                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
26860         }
26861         if (*(*(struct {
26862                 Type AnimType
26863
26864                 //mt:if %s.Type == SpriteSheetAnim
26865                 AspectRatio [2]uint8
26866
26867                 //mt:if %s.Type == VerticalFrameAnim
26868                 NFrames [2]uint16
26869
26870                 //mt:if %s.Type != NoAnim
26871                 Duration float32 // in seconds
26872
26873         }))(obj)).Type == SpriteSheetAnim {
26874                 {
26875                         _, err := w.Write(((*(*(struct {
26876                                 Type AnimType
26877
26878                                 //mt:if %s.Type == SpriteSheetAnim
26879                                 AspectRatio [2]uint8
26880
26881                                 //mt:if %s.Type == VerticalFrameAnim
26882                                 NFrames [2]uint16
26883
26884                                 //mt:if %s.Type != NoAnim
26885                                 Duration float32 // in seconds
26886
26887                         }))(obj)).AspectRatio)[:])
26888                         chk(err)
26889                 }
26890         }
26891         if (*(*(struct {
26892                 Type AnimType
26893
26894                 //mt:if %s.Type == SpriteSheetAnim
26895                 AspectRatio [2]uint8
26896
26897                 //mt:if %s.Type == VerticalFrameAnim
26898                 NFrames [2]uint16
26899
26900                 //mt:if %s.Type != NoAnim
26901                 Duration float32 // in seconds
26902
26903         }))(obj)).Type == VerticalFrameAnim {
26904                 for local310 := range (*(*(struct {
26905                         Type AnimType
26906
26907                         //mt:if %s.Type == SpriteSheetAnim
26908                         AspectRatio [2]uint8
26909
26910                         //mt:if %s.Type == VerticalFrameAnim
26911                         NFrames [2]uint16
26912
26913                         //mt:if %s.Type != NoAnim
26914                         Duration float32 // in seconds
26915
26916                 }))(obj)).NFrames {
26917                         {
26918                                 x := ((*(*(struct {
26919                                         Type AnimType
26920
26921                                         //mt:if %s.Type == SpriteSheetAnim
26922                                         AspectRatio [2]uint8
26923
26924                                         //mt:if %s.Type == VerticalFrameAnim
26925                                         NFrames [2]uint16
26926
26927                                         //mt:if %s.Type != NoAnim
26928                                         Duration float32 // in seconds
26929
26930                                 }))(obj)).NFrames)[local310]
26931                                 write16(w, uint16(x))
26932                         }
26933                 }
26934         }
26935         if (*(*(struct {
26936                 Type AnimType
26937
26938                 //mt:if %s.Type == SpriteSheetAnim
26939                 AspectRatio [2]uint8
26940
26941                 //mt:if %s.Type == VerticalFrameAnim
26942                 NFrames [2]uint16
26943
26944                 //mt:if %s.Type != NoAnim
26945                 Duration float32 // in seconds
26946
26947         }))(obj)).Type != NoAnim {
26948                 {
26949                         x := (*(*(struct {
26950                                 Type AnimType
26951
26952                                 //mt:if %s.Type == SpriteSheetAnim
26953                                 AspectRatio [2]uint8
26954
26955                                 //mt:if %s.Type == VerticalFrameAnim
26956                                 NFrames [2]uint16
26957
26958                                 //mt:if %s.Type != NoAnim
26959                                 Duration float32 // in seconds
26960
26961                         }))(obj)).Duration
26962                         write32(w, math.Float32bits(x))
26963                 }
26964         }
26965 }
26966
26967 func (obj *TileAnim) deserialize(r io.Reader) {
26968         if err := pcall(func() {
26969                 ((*(*(struct {
26970                         Type AnimType
26971
26972                         //mt:if %s.Type == SpriteSheetAnim
26973                         AspectRatio [2]uint8
26974
26975                         //mt:if %s.Type == VerticalFrameAnim
26976                         NFrames [2]uint16
26977
26978                         //mt:if %s.Type != NoAnim
26979                         Duration float32 // in seconds
26980
26981                 }))(obj)).Type).deserialize(r)
26982         }); err != nil {
26983                 if err == io.EOF {
26984                         chk(io.EOF)
26985                 }
26986                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AnimType", err))
26987         }
26988         if !((*(*(struct {
26989                 Type AnimType
26990
26991                 //mt:if %s.Type == SpriteSheetAnim
26992                 AspectRatio [2]uint8
26993
26994                 //mt:if %s.Type == VerticalFrameAnim
26995                 NFrames [2]uint16
26996
26997                 //mt:if %s.Type != NoAnim
26998                 Duration float32 // in seconds
26999
27000         }))(obj)).Type < maxAnim) {
27001                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
27002         }
27003         if (*(*(struct {
27004                 Type AnimType
27005
27006                 //mt:if %s.Type == SpriteSheetAnim
27007                 AspectRatio [2]uint8
27008
27009                 //mt:if %s.Type == VerticalFrameAnim
27010                 NFrames [2]uint16
27011
27012                 //mt:if %s.Type != NoAnim
27013                 Duration float32 // in seconds
27014
27015         }))(obj)).Type == SpriteSheetAnim {
27016                 {
27017                         _, err := io.ReadFull(r, ((*(*(struct {
27018                                 Type AnimType
27019
27020                                 //mt:if %s.Type == SpriteSheetAnim
27021                                 AspectRatio [2]uint8
27022
27023                                 //mt:if %s.Type == VerticalFrameAnim
27024                                 NFrames [2]uint16
27025
27026                                 //mt:if %s.Type != NoAnim
27027                                 Duration float32 // in seconds
27028
27029                         }))(obj)).AspectRatio)[:])
27030                         chk(err)
27031                 }
27032         }
27033         if (*(*(struct {
27034                 Type AnimType
27035
27036                 //mt:if %s.Type == SpriteSheetAnim
27037                 AspectRatio [2]uint8
27038
27039                 //mt:if %s.Type == VerticalFrameAnim
27040                 NFrames [2]uint16
27041
27042                 //mt:if %s.Type != NoAnim
27043                 Duration float32 // in seconds
27044
27045         }))(obj)).Type == VerticalFrameAnim {
27046                 for local311 := range (*(*(struct {
27047                         Type AnimType
27048
27049                         //mt:if %s.Type == SpriteSheetAnim
27050                         AspectRatio [2]uint8
27051
27052                         //mt:if %s.Type == VerticalFrameAnim
27053                         NFrames [2]uint16
27054
27055                         //mt:if %s.Type != NoAnim
27056                         Duration float32 // in seconds
27057
27058                 }))(obj)).NFrames {
27059                         {
27060                                 p := &((*(*(struct {
27061                                         Type AnimType
27062
27063                                         //mt:if %s.Type == SpriteSheetAnim
27064                                         AspectRatio [2]uint8
27065
27066                                         //mt:if %s.Type == VerticalFrameAnim
27067                                         NFrames [2]uint16
27068
27069                                         //mt:if %s.Type != NoAnim
27070                                         Duration float32 // in seconds
27071
27072                                 }))(obj)).NFrames)[local311]
27073                                 *p = read16(r)
27074                         }
27075                 }
27076         }
27077         if (*(*(struct {
27078                 Type AnimType
27079
27080                 //mt:if %s.Type == SpriteSheetAnim
27081                 AspectRatio [2]uint8
27082
27083                 //mt:if %s.Type == VerticalFrameAnim
27084                 NFrames [2]uint16
27085
27086                 //mt:if %s.Type != NoAnim
27087                 Duration float32 // in seconds
27088
27089         }))(obj)).Type != NoAnim {
27090                 {
27091                         p := &(*(*(struct {
27092                                 Type AnimType
27093
27094                                 //mt:if %s.Type == SpriteSheetAnim
27095                                 AspectRatio [2]uint8
27096
27097                                 //mt:if %s.Type == VerticalFrameAnim
27098                                 NFrames [2]uint16
27099
27100                                 //mt:if %s.Type != NoAnim
27101                                 Duration float32 // in seconds
27102
27103                         }))(obj)).Duration
27104                         *p = math.Float32frombits(read32(r))
27105                 }
27106         }
27107 }
27108
27109 func (obj *Content) serialize(w io.Writer) {
27110         {
27111                 x := *(*(uint16))(obj)
27112                 write16(w, uint16(x))
27113         }
27114 }
27115
27116 func (obj *Content) deserialize(r io.Reader) {
27117         {
27118                 p := &*(*(uint16))(obj)
27119                 *p = read16(r)
27120         }
27121 }
27122
27123 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
27124         {
27125                 x := *(*(uint32))(obj)
27126                 write32(w, uint32(x))
27127         }
27128 }
27129
27130 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
27131         {
27132                 p := &*(*(uint32))(obj)
27133                 *p = read32(r)
27134         }
27135 }
27136
27137 func (obj *HUDID) serialize(w io.Writer) {
27138         {
27139                 x := *(*(uint32))(obj)
27140                 write32(w, uint32(x))
27141         }
27142 }
27143
27144 func (obj *HUDID) deserialize(r io.Reader) {
27145         {
27146                 p := &*(*(uint32))(obj)
27147                 *p = read32(r)
27148         }
27149 }
27150
27151 func (obj *HUD) serialize(w io.Writer) {
27152         if err := pcall(func() {
27153                 ((*(*(struct {
27154                         Type HUDType
27155
27156                         Pos      [2]float32
27157                         Name     string
27158                         Scale    [2]float32
27159                         Text     string
27160                         Number   uint32
27161                         Item     uint32
27162                         Dir      uint32
27163                         Align    [2]float32
27164                         Offset   [2]float32
27165                         WorldPos Pos
27166                         Size     [2]int32
27167                         ZIndex   int16
27168                         Text2    string
27169                         Style    uint32
27170                 }))(obj)).Type).serialize(w)
27171         }); err != nil {
27172                 if err == io.EOF {
27173                         chk(io.EOF)
27174                 }
27175                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
27176         }
27177         for local312 := range (*(*(struct {
27178                 Type HUDType
27179
27180                 Pos      [2]float32
27181                 Name     string
27182                 Scale    [2]float32
27183                 Text     string
27184                 Number   uint32
27185                 Item     uint32
27186                 Dir      uint32
27187                 Align    [2]float32
27188                 Offset   [2]float32
27189                 WorldPos Pos
27190                 Size     [2]int32
27191                 ZIndex   int16
27192                 Text2    string
27193                 Style    uint32
27194         }))(obj)).Pos {
27195                 {
27196                         x := ((*(*(struct {
27197                                 Type HUDType
27198
27199                                 Pos      [2]float32
27200                                 Name     string
27201                                 Scale    [2]float32
27202                                 Text     string
27203                                 Number   uint32
27204                                 Item     uint32
27205                                 Dir      uint32
27206                                 Align    [2]float32
27207                                 Offset   [2]float32
27208                                 WorldPos Pos
27209                                 Size     [2]int32
27210                                 ZIndex   int16
27211                                 Text2    string
27212                                 Style    uint32
27213                         }))(obj)).Pos)[local312]
27214                         write32(w, math.Float32bits(x))
27215                 }
27216         }
27217         if len(([]byte((*(*(struct {
27218                 Type HUDType
27219
27220                 Pos      [2]float32
27221                 Name     string
27222                 Scale    [2]float32
27223                 Text     string
27224                 Number   uint32
27225                 Item     uint32
27226                 Dir      uint32
27227                 Align    [2]float32
27228                 Offset   [2]float32
27229                 WorldPos Pos
27230                 Size     [2]int32
27231                 ZIndex   int16
27232                 Text2    string
27233                 Style    uint32
27234         }))(obj)).Name))) > math.MaxUint16 {
27235                 chk(ErrTooLong)
27236         }
27237         {
27238                 x := uint16(len(([]byte((*(*(struct {
27239                         Type HUDType
27240
27241                         Pos      [2]float32
27242                         Name     string
27243                         Scale    [2]float32
27244                         Text     string
27245                         Number   uint32
27246                         Item     uint32
27247                         Dir      uint32
27248                         Align    [2]float32
27249                         Offset   [2]float32
27250                         WorldPos Pos
27251                         Size     [2]int32
27252                         ZIndex   int16
27253                         Text2    string
27254                         Style    uint32
27255                 }))(obj)).Name))))
27256                 write16(w, uint16(x))
27257         }
27258         {
27259                 _, err := w.Write(([]byte((*(*(struct {
27260                         Type HUDType
27261
27262                         Pos      [2]float32
27263                         Name     string
27264                         Scale    [2]float32
27265                         Text     string
27266                         Number   uint32
27267                         Item     uint32
27268                         Dir      uint32
27269                         Align    [2]float32
27270                         Offset   [2]float32
27271                         WorldPos Pos
27272                         Size     [2]int32
27273                         ZIndex   int16
27274                         Text2    string
27275                         Style    uint32
27276                 }))(obj)).Name))[:])
27277                 chk(err)
27278         }
27279         for local313 := range (*(*(struct {
27280                 Type HUDType
27281
27282                 Pos      [2]float32
27283                 Name     string
27284                 Scale    [2]float32
27285                 Text     string
27286                 Number   uint32
27287                 Item     uint32
27288                 Dir      uint32
27289                 Align    [2]float32
27290                 Offset   [2]float32
27291                 WorldPos Pos
27292                 Size     [2]int32
27293                 ZIndex   int16
27294                 Text2    string
27295                 Style    uint32
27296         }))(obj)).Scale {
27297                 {
27298                         x := ((*(*(struct {
27299                                 Type HUDType
27300
27301                                 Pos      [2]float32
27302                                 Name     string
27303                                 Scale    [2]float32
27304                                 Text     string
27305                                 Number   uint32
27306                                 Item     uint32
27307                                 Dir      uint32
27308                                 Align    [2]float32
27309                                 Offset   [2]float32
27310                                 WorldPos Pos
27311                                 Size     [2]int32
27312                                 ZIndex   int16
27313                                 Text2    string
27314                                 Style    uint32
27315                         }))(obj)).Scale)[local313]
27316                         write32(w, math.Float32bits(x))
27317                 }
27318         }
27319         if len(([]byte((*(*(struct {
27320                 Type HUDType
27321
27322                 Pos      [2]float32
27323                 Name     string
27324                 Scale    [2]float32
27325                 Text     string
27326                 Number   uint32
27327                 Item     uint32
27328                 Dir      uint32
27329                 Align    [2]float32
27330                 Offset   [2]float32
27331                 WorldPos Pos
27332                 Size     [2]int32
27333                 ZIndex   int16
27334                 Text2    string
27335                 Style    uint32
27336         }))(obj)).Text))) > math.MaxUint16 {
27337                 chk(ErrTooLong)
27338         }
27339         {
27340                 x := uint16(len(([]byte((*(*(struct {
27341                         Type HUDType
27342
27343                         Pos      [2]float32
27344                         Name     string
27345                         Scale    [2]float32
27346                         Text     string
27347                         Number   uint32
27348                         Item     uint32
27349                         Dir      uint32
27350                         Align    [2]float32
27351                         Offset   [2]float32
27352                         WorldPos Pos
27353                         Size     [2]int32
27354                         ZIndex   int16
27355                         Text2    string
27356                         Style    uint32
27357                 }))(obj)).Text))))
27358                 write16(w, uint16(x))
27359         }
27360         {
27361                 _, err := w.Write(([]byte((*(*(struct {
27362                         Type HUDType
27363
27364                         Pos      [2]float32
27365                         Name     string
27366                         Scale    [2]float32
27367                         Text     string
27368                         Number   uint32
27369                         Item     uint32
27370                         Dir      uint32
27371                         Align    [2]float32
27372                         Offset   [2]float32
27373                         WorldPos Pos
27374                         Size     [2]int32
27375                         ZIndex   int16
27376                         Text2    string
27377                         Style    uint32
27378                 }))(obj)).Text))[:])
27379                 chk(err)
27380         }
27381         {
27382                 x := (*(*(struct {
27383                         Type HUDType
27384
27385                         Pos      [2]float32
27386                         Name     string
27387                         Scale    [2]float32
27388                         Text     string
27389                         Number   uint32
27390                         Item     uint32
27391                         Dir      uint32
27392                         Align    [2]float32
27393                         Offset   [2]float32
27394                         WorldPos Pos
27395                         Size     [2]int32
27396                         ZIndex   int16
27397                         Text2    string
27398                         Style    uint32
27399                 }))(obj)).Number
27400                 write32(w, uint32(x))
27401         }
27402         {
27403                 x := (*(*(struct {
27404                         Type HUDType
27405
27406                         Pos      [2]float32
27407                         Name     string
27408                         Scale    [2]float32
27409                         Text     string
27410                         Number   uint32
27411                         Item     uint32
27412                         Dir      uint32
27413                         Align    [2]float32
27414                         Offset   [2]float32
27415                         WorldPos Pos
27416                         Size     [2]int32
27417                         ZIndex   int16
27418                         Text2    string
27419                         Style    uint32
27420                 }))(obj)).Item
27421                 write32(w, uint32(x))
27422         }
27423         {
27424                 x := (*(*(struct {
27425                         Type HUDType
27426
27427                         Pos      [2]float32
27428                         Name     string
27429                         Scale    [2]float32
27430                         Text     string
27431                         Number   uint32
27432                         Item     uint32
27433                         Dir      uint32
27434                         Align    [2]float32
27435                         Offset   [2]float32
27436                         WorldPos Pos
27437                         Size     [2]int32
27438                         ZIndex   int16
27439                         Text2    string
27440                         Style    uint32
27441                 }))(obj)).Dir
27442                 write32(w, uint32(x))
27443         }
27444         for local314 := range (*(*(struct {
27445                 Type HUDType
27446
27447                 Pos      [2]float32
27448                 Name     string
27449                 Scale    [2]float32
27450                 Text     string
27451                 Number   uint32
27452                 Item     uint32
27453                 Dir      uint32
27454                 Align    [2]float32
27455                 Offset   [2]float32
27456                 WorldPos Pos
27457                 Size     [2]int32
27458                 ZIndex   int16
27459                 Text2    string
27460                 Style    uint32
27461         }))(obj)).Align {
27462                 {
27463                         x := ((*(*(struct {
27464                                 Type HUDType
27465
27466                                 Pos      [2]float32
27467                                 Name     string
27468                                 Scale    [2]float32
27469                                 Text     string
27470                                 Number   uint32
27471                                 Item     uint32
27472                                 Dir      uint32
27473                                 Align    [2]float32
27474                                 Offset   [2]float32
27475                                 WorldPos Pos
27476                                 Size     [2]int32
27477                                 ZIndex   int16
27478                                 Text2    string
27479                                 Style    uint32
27480                         }))(obj)).Align)[local314]
27481                         write32(w, math.Float32bits(x))
27482                 }
27483         }
27484         for local315 := range (*(*(struct {
27485                 Type HUDType
27486
27487                 Pos      [2]float32
27488                 Name     string
27489                 Scale    [2]float32
27490                 Text     string
27491                 Number   uint32
27492                 Item     uint32
27493                 Dir      uint32
27494                 Align    [2]float32
27495                 Offset   [2]float32
27496                 WorldPos Pos
27497                 Size     [2]int32
27498                 ZIndex   int16
27499                 Text2    string
27500                 Style    uint32
27501         }))(obj)).Offset {
27502                 {
27503                         x := ((*(*(struct {
27504                                 Type HUDType
27505
27506                                 Pos      [2]float32
27507                                 Name     string
27508                                 Scale    [2]float32
27509                                 Text     string
27510                                 Number   uint32
27511                                 Item     uint32
27512                                 Dir      uint32
27513                                 Align    [2]float32
27514                                 Offset   [2]float32
27515                                 WorldPos Pos
27516                                 Size     [2]int32
27517                                 ZIndex   int16
27518                                 Text2    string
27519                                 Style    uint32
27520                         }))(obj)).Offset)[local315]
27521                         write32(w, math.Float32bits(x))
27522                 }
27523         }
27524         if err := pcall(func() {
27525                 ((*(*(struct {
27526                         Type HUDType
27527
27528                         Pos      [2]float32
27529                         Name     string
27530                         Scale    [2]float32
27531                         Text     string
27532                         Number   uint32
27533                         Item     uint32
27534                         Dir      uint32
27535                         Align    [2]float32
27536                         Offset   [2]float32
27537                         WorldPos Pos
27538                         Size     [2]int32
27539                         ZIndex   int16
27540                         Text2    string
27541                         Style    uint32
27542                 }))(obj)).WorldPos).serialize(w)
27543         }); err != nil {
27544                 if err == io.EOF {
27545                         chk(io.EOF)
27546                 }
27547                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
27548         }
27549         for local316 := range (*(*(struct {
27550                 Type HUDType
27551
27552                 Pos      [2]float32
27553                 Name     string
27554                 Scale    [2]float32
27555                 Text     string
27556                 Number   uint32
27557                 Item     uint32
27558                 Dir      uint32
27559                 Align    [2]float32
27560                 Offset   [2]float32
27561                 WorldPos Pos
27562                 Size     [2]int32
27563                 ZIndex   int16
27564                 Text2    string
27565                 Style    uint32
27566         }))(obj)).Size {
27567                 {
27568                         x := ((*(*(struct {
27569                                 Type HUDType
27570
27571                                 Pos      [2]float32
27572                                 Name     string
27573                                 Scale    [2]float32
27574                                 Text     string
27575                                 Number   uint32
27576                                 Item     uint32
27577                                 Dir      uint32
27578                                 Align    [2]float32
27579                                 Offset   [2]float32
27580                                 WorldPos Pos
27581                                 Size     [2]int32
27582                                 ZIndex   int16
27583                                 Text2    string
27584                                 Style    uint32
27585                         }))(obj)).Size)[local316]
27586                         write32(w, uint32(x))
27587                 }
27588         }
27589         {
27590                 x := (*(*(struct {
27591                         Type HUDType
27592
27593                         Pos      [2]float32
27594                         Name     string
27595                         Scale    [2]float32
27596                         Text     string
27597                         Number   uint32
27598                         Item     uint32
27599                         Dir      uint32
27600                         Align    [2]float32
27601                         Offset   [2]float32
27602                         WorldPos Pos
27603                         Size     [2]int32
27604                         ZIndex   int16
27605                         Text2    string
27606                         Style    uint32
27607                 }))(obj)).ZIndex
27608                 write16(w, uint16(x))
27609         }
27610         if len(([]byte((*(*(struct {
27611                 Type HUDType
27612
27613                 Pos      [2]float32
27614                 Name     string
27615                 Scale    [2]float32
27616                 Text     string
27617                 Number   uint32
27618                 Item     uint32
27619                 Dir      uint32
27620                 Align    [2]float32
27621                 Offset   [2]float32
27622                 WorldPos Pos
27623                 Size     [2]int32
27624                 ZIndex   int16
27625                 Text2    string
27626                 Style    uint32
27627         }))(obj)).Text2))) > math.MaxUint16 {
27628                 chk(ErrTooLong)
27629         }
27630         {
27631                 x := uint16(len(([]byte((*(*(struct {
27632                         Type HUDType
27633
27634                         Pos      [2]float32
27635                         Name     string
27636                         Scale    [2]float32
27637                         Text     string
27638                         Number   uint32
27639                         Item     uint32
27640                         Dir      uint32
27641                         Align    [2]float32
27642                         Offset   [2]float32
27643                         WorldPos Pos
27644                         Size     [2]int32
27645                         ZIndex   int16
27646                         Text2    string
27647                         Style    uint32
27648                 }))(obj)).Text2))))
27649                 write16(w, uint16(x))
27650         }
27651         {
27652                 _, err := w.Write(([]byte((*(*(struct {
27653                         Type HUDType
27654
27655                         Pos      [2]float32
27656                         Name     string
27657                         Scale    [2]float32
27658                         Text     string
27659                         Number   uint32
27660                         Item     uint32
27661                         Dir      uint32
27662                         Align    [2]float32
27663                         Offset   [2]float32
27664                         WorldPos Pos
27665                         Size     [2]int32
27666                         ZIndex   int16
27667                         Text2    string
27668                         Style    uint32
27669                 }))(obj)).Text2))[:])
27670                 chk(err)
27671         }
27672         {
27673                 x := (*(*(struct {
27674                         Type HUDType
27675
27676                         Pos      [2]float32
27677                         Name     string
27678                         Scale    [2]float32
27679                         Text     string
27680                         Number   uint32
27681                         Item     uint32
27682                         Dir      uint32
27683                         Align    [2]float32
27684                         Offset   [2]float32
27685                         WorldPos Pos
27686                         Size     [2]int32
27687                         ZIndex   int16
27688                         Text2    string
27689                         Style    uint32
27690                 }))(obj)).Style
27691                 write32(w, uint32(x))
27692         }
27693 }
27694
27695 func (obj *HUD) deserialize(r io.Reader) {
27696         if err := pcall(func() {
27697                 ((*(*(struct {
27698                         Type HUDType
27699
27700                         Pos      [2]float32
27701                         Name     string
27702                         Scale    [2]float32
27703                         Text     string
27704                         Number   uint32
27705                         Item     uint32
27706                         Dir      uint32
27707                         Align    [2]float32
27708                         Offset   [2]float32
27709                         WorldPos Pos
27710                         Size     [2]int32
27711                         ZIndex   int16
27712                         Text2    string
27713                         Style    uint32
27714                 }))(obj)).Type).deserialize(r)
27715         }); err != nil {
27716                 if err == io.EOF {
27717                         chk(io.EOF)
27718                 }
27719                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
27720         }
27721         for local317 := range (*(*(struct {
27722                 Type HUDType
27723
27724                 Pos      [2]float32
27725                 Name     string
27726                 Scale    [2]float32
27727                 Text     string
27728                 Number   uint32
27729                 Item     uint32
27730                 Dir      uint32
27731                 Align    [2]float32
27732                 Offset   [2]float32
27733                 WorldPos Pos
27734                 Size     [2]int32
27735                 ZIndex   int16
27736                 Text2    string
27737                 Style    uint32
27738         }))(obj)).Pos {
27739                 {
27740                         p := &((*(*(struct {
27741                                 Type HUDType
27742
27743                                 Pos      [2]float32
27744                                 Name     string
27745                                 Scale    [2]float32
27746                                 Text     string
27747                                 Number   uint32
27748                                 Item     uint32
27749                                 Dir      uint32
27750                                 Align    [2]float32
27751                                 Offset   [2]float32
27752                                 WorldPos Pos
27753                                 Size     [2]int32
27754                                 ZIndex   int16
27755                                 Text2    string
27756                                 Style    uint32
27757                         }))(obj)).Pos)[local317]
27758                         *p = math.Float32frombits(read32(r))
27759                 }
27760         }
27761         var local318 []uint8
27762         var local319 uint16
27763         {
27764                 p := &local319
27765                 *p = read16(r)
27766         }
27767         (local318) = make([]uint8, local319)
27768         {
27769                 _, err := io.ReadFull(r, (local318)[:])
27770                 chk(err)
27771         }
27772         ((*(*(struct {
27773                 Type HUDType
27774
27775                 Pos      [2]float32
27776                 Name     string
27777                 Scale    [2]float32
27778                 Text     string
27779                 Number   uint32
27780                 Item     uint32
27781                 Dir      uint32
27782                 Align    [2]float32
27783                 Offset   [2]float32
27784                 WorldPos Pos
27785                 Size     [2]int32
27786                 ZIndex   int16
27787                 Text2    string
27788                 Style    uint32
27789         }))(obj)).Name) = string(local318)
27790         for local320 := range (*(*(struct {
27791                 Type HUDType
27792
27793                 Pos      [2]float32
27794                 Name     string
27795                 Scale    [2]float32
27796                 Text     string
27797                 Number   uint32
27798                 Item     uint32
27799                 Dir      uint32
27800                 Align    [2]float32
27801                 Offset   [2]float32
27802                 WorldPos Pos
27803                 Size     [2]int32
27804                 ZIndex   int16
27805                 Text2    string
27806                 Style    uint32
27807         }))(obj)).Scale {
27808                 {
27809                         p := &((*(*(struct {
27810                                 Type HUDType
27811
27812                                 Pos      [2]float32
27813                                 Name     string
27814                                 Scale    [2]float32
27815                                 Text     string
27816                                 Number   uint32
27817                                 Item     uint32
27818                                 Dir      uint32
27819                                 Align    [2]float32
27820                                 Offset   [2]float32
27821                                 WorldPos Pos
27822                                 Size     [2]int32
27823                                 ZIndex   int16
27824                                 Text2    string
27825                                 Style    uint32
27826                         }))(obj)).Scale)[local320]
27827                         *p = math.Float32frombits(read32(r))
27828                 }
27829         }
27830         var local321 []uint8
27831         var local322 uint16
27832         {
27833                 p := &local322
27834                 *p = read16(r)
27835         }
27836         (local321) = make([]uint8, local322)
27837         {
27838                 _, err := io.ReadFull(r, (local321)[:])
27839                 chk(err)
27840         }
27841         ((*(*(struct {
27842                 Type HUDType
27843
27844                 Pos      [2]float32
27845                 Name     string
27846                 Scale    [2]float32
27847                 Text     string
27848                 Number   uint32
27849                 Item     uint32
27850                 Dir      uint32
27851                 Align    [2]float32
27852                 Offset   [2]float32
27853                 WorldPos Pos
27854                 Size     [2]int32
27855                 ZIndex   int16
27856                 Text2    string
27857                 Style    uint32
27858         }))(obj)).Text) = string(local321)
27859         {
27860                 p := &(*(*(struct {
27861                         Type HUDType
27862
27863                         Pos      [2]float32
27864                         Name     string
27865                         Scale    [2]float32
27866                         Text     string
27867                         Number   uint32
27868                         Item     uint32
27869                         Dir      uint32
27870                         Align    [2]float32
27871                         Offset   [2]float32
27872                         WorldPos Pos
27873                         Size     [2]int32
27874                         ZIndex   int16
27875                         Text2    string
27876                         Style    uint32
27877                 }))(obj)).Number
27878                 *p = read32(r)
27879         }
27880         {
27881                 p := &(*(*(struct {
27882                         Type HUDType
27883
27884                         Pos      [2]float32
27885                         Name     string
27886                         Scale    [2]float32
27887                         Text     string
27888                         Number   uint32
27889                         Item     uint32
27890                         Dir      uint32
27891                         Align    [2]float32
27892                         Offset   [2]float32
27893                         WorldPos Pos
27894                         Size     [2]int32
27895                         ZIndex   int16
27896                         Text2    string
27897                         Style    uint32
27898                 }))(obj)).Item
27899                 *p = read32(r)
27900         }
27901         {
27902                 p := &(*(*(struct {
27903                         Type HUDType
27904
27905                         Pos      [2]float32
27906                         Name     string
27907                         Scale    [2]float32
27908                         Text     string
27909                         Number   uint32
27910                         Item     uint32
27911                         Dir      uint32
27912                         Align    [2]float32
27913                         Offset   [2]float32
27914                         WorldPos Pos
27915                         Size     [2]int32
27916                         ZIndex   int16
27917                         Text2    string
27918                         Style    uint32
27919                 }))(obj)).Dir
27920                 *p = read32(r)
27921         }
27922         for local323 := range (*(*(struct {
27923                 Type HUDType
27924
27925                 Pos      [2]float32
27926                 Name     string
27927                 Scale    [2]float32
27928                 Text     string
27929                 Number   uint32
27930                 Item     uint32
27931                 Dir      uint32
27932                 Align    [2]float32
27933                 Offset   [2]float32
27934                 WorldPos Pos
27935                 Size     [2]int32
27936                 ZIndex   int16
27937                 Text2    string
27938                 Style    uint32
27939         }))(obj)).Align {
27940                 {
27941                         p := &((*(*(struct {
27942                                 Type HUDType
27943
27944                                 Pos      [2]float32
27945                                 Name     string
27946                                 Scale    [2]float32
27947                                 Text     string
27948                                 Number   uint32
27949                                 Item     uint32
27950                                 Dir      uint32
27951                                 Align    [2]float32
27952                                 Offset   [2]float32
27953                                 WorldPos Pos
27954                                 Size     [2]int32
27955                                 ZIndex   int16
27956                                 Text2    string
27957                                 Style    uint32
27958                         }))(obj)).Align)[local323]
27959                         *p = math.Float32frombits(read32(r))
27960                 }
27961         }
27962         for local324 := range (*(*(struct {
27963                 Type HUDType
27964
27965                 Pos      [2]float32
27966                 Name     string
27967                 Scale    [2]float32
27968                 Text     string
27969                 Number   uint32
27970                 Item     uint32
27971                 Dir      uint32
27972                 Align    [2]float32
27973                 Offset   [2]float32
27974                 WorldPos Pos
27975                 Size     [2]int32
27976                 ZIndex   int16
27977                 Text2    string
27978                 Style    uint32
27979         }))(obj)).Offset {
27980                 {
27981                         p := &((*(*(struct {
27982                                 Type HUDType
27983
27984                                 Pos      [2]float32
27985                                 Name     string
27986                                 Scale    [2]float32
27987                                 Text     string
27988                                 Number   uint32
27989                                 Item     uint32
27990                                 Dir      uint32
27991                                 Align    [2]float32
27992                                 Offset   [2]float32
27993                                 WorldPos Pos
27994                                 Size     [2]int32
27995                                 ZIndex   int16
27996                                 Text2    string
27997                                 Style    uint32
27998                         }))(obj)).Offset)[local324]
27999                         *p = math.Float32frombits(read32(r))
28000                 }
28001         }
28002         if err := pcall(func() {
28003                 ((*(*(struct {
28004                         Type HUDType
28005
28006                         Pos      [2]float32
28007                         Name     string
28008                         Scale    [2]float32
28009                         Text     string
28010                         Number   uint32
28011                         Item     uint32
28012                         Dir      uint32
28013                         Align    [2]float32
28014                         Offset   [2]float32
28015                         WorldPos Pos
28016                         Size     [2]int32
28017                         ZIndex   int16
28018                         Text2    string
28019                         Style    uint32
28020                 }))(obj)).WorldPos).deserialize(r)
28021         }); err != nil {
28022                 if err == io.EOF {
28023                         chk(io.EOF)
28024                 }
28025                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
28026         }
28027         for local325 := range (*(*(struct {
28028                 Type HUDType
28029
28030                 Pos      [2]float32
28031                 Name     string
28032                 Scale    [2]float32
28033                 Text     string
28034                 Number   uint32
28035                 Item     uint32
28036                 Dir      uint32
28037                 Align    [2]float32
28038                 Offset   [2]float32
28039                 WorldPos Pos
28040                 Size     [2]int32
28041                 ZIndex   int16
28042                 Text2    string
28043                 Style    uint32
28044         }))(obj)).Size {
28045                 {
28046                         p := &((*(*(struct {
28047                                 Type HUDType
28048
28049                                 Pos      [2]float32
28050                                 Name     string
28051                                 Scale    [2]float32
28052                                 Text     string
28053                                 Number   uint32
28054                                 Item     uint32
28055                                 Dir      uint32
28056                                 Align    [2]float32
28057                                 Offset   [2]float32
28058                                 WorldPos Pos
28059                                 Size     [2]int32
28060                                 ZIndex   int16
28061                                 Text2    string
28062                                 Style    uint32
28063                         }))(obj)).Size)[local325]
28064                         *p = int32(read32(r))
28065                 }
28066         }
28067         {
28068                 p := &(*(*(struct {
28069                         Type HUDType
28070
28071                         Pos      [2]float32
28072                         Name     string
28073                         Scale    [2]float32
28074                         Text     string
28075                         Number   uint32
28076                         Item     uint32
28077                         Dir      uint32
28078                         Align    [2]float32
28079                         Offset   [2]float32
28080                         WorldPos Pos
28081                         Size     [2]int32
28082                         ZIndex   int16
28083                         Text2    string
28084                         Style    uint32
28085                 }))(obj)).ZIndex
28086                 *p = int16(read16(r))
28087         }
28088         var local326 []uint8
28089         var local327 uint16
28090         {
28091                 p := &local327
28092                 *p = read16(r)
28093         }
28094         (local326) = make([]uint8, local327)
28095         {
28096                 _, err := io.ReadFull(r, (local326)[:])
28097                 chk(err)
28098         }
28099         ((*(*(struct {
28100                 Type HUDType
28101
28102                 Pos      [2]float32
28103                 Name     string
28104                 Scale    [2]float32
28105                 Text     string
28106                 Number   uint32
28107                 Item     uint32
28108                 Dir      uint32
28109                 Align    [2]float32
28110                 Offset   [2]float32
28111                 WorldPos Pos
28112                 Size     [2]int32
28113                 ZIndex   int16
28114                 Text2    string
28115                 Style    uint32
28116         }))(obj)).Text2) = string(local326)
28117         {
28118                 p := &(*(*(struct {
28119                         Type HUDType
28120
28121                         Pos      [2]float32
28122                         Name     string
28123                         Scale    [2]float32
28124                         Text     string
28125                         Number   uint32
28126                         Item     uint32
28127                         Dir      uint32
28128                         Align    [2]float32
28129                         Offset   [2]float32
28130                         WorldPos Pos
28131                         Size     [2]int32
28132                         ZIndex   int16
28133                         Text2    string
28134                         Style    uint32
28135                 }))(obj)).Style
28136                 *p = read32(r)
28137         }
28138 }
28139
28140 func (obj *HUDField) serialize(w io.Writer) {
28141         {
28142                 x := *(*(uint8))(obj)
28143                 write8(w, uint8(x))
28144         }
28145 }
28146
28147 func (obj *HUDField) deserialize(r io.Reader) {
28148         {
28149                 p := &*(*(uint8))(obj)
28150                 *p = read8(r)
28151         }
28152 }
28153
28154 func (obj *HUDStyleFlags) serialize(w io.Writer) {
28155         {
28156                 x := *(*(uint32))(obj)
28157                 write32(w, uint32(x))
28158         }
28159 }
28160
28161 func (obj *HUDStyleFlags) deserialize(r io.Reader) {
28162         {
28163                 p := &*(*(uint32))(obj)
28164                 *p = read32(r)
28165         }
28166 }
28167
28168 func (obj *HUDFlags) serialize(w io.Writer) {
28169         {
28170                 x := *(*(uint32))(obj)
28171                 write32(w, uint32(x))
28172         }
28173 }
28174
28175 func (obj *HUDFlags) deserialize(r io.Reader) {
28176         {
28177                 p := &*(*(uint32))(obj)
28178                 *p = read32(r)
28179         }
28180 }
28181
28182 func (obj *HotbarParam) serialize(w io.Writer) {
28183         {
28184                 x := *(*(uint16))(obj)
28185                 write16(w, uint16(x))
28186         }
28187 }
28188
28189 func (obj *HotbarParam) deserialize(r io.Reader) {
28190         {
28191                 p := &*(*(uint16))(obj)
28192                 *p = read16(r)
28193         }
28194 }
28195
28196 func (obj *Texture) serialize(w io.Writer) {
28197         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
28198                 chk(ErrTooLong)
28199         }
28200         {
28201                 x := uint16(len(([]byte(*(*(string))(obj)))))
28202                 write16(w, uint16(x))
28203         }
28204         {
28205                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
28206                 chk(err)
28207         }
28208 }
28209
28210 func (obj *Texture) deserialize(r io.Reader) {
28211         var local328 []uint8
28212         var local329 uint16
28213         {
28214                 p := &local329
28215                 *p = read16(r)
28216         }
28217         (local328) = make([]uint8, local329)
28218         {
28219                 _, err := io.ReadFull(r, (local328)[:])
28220                 chk(err)
28221         }
28222         (*(*(string))(obj)) = string(local328)
28223 }
28224
28225 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
28226         {
28227                 x := *(*(uint8))(obj)
28228                 write8(w, uint8(x))
28229         }
28230 }
28231
28232 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
28233         {
28234                 p := &*(*(uint8))(obj)
28235                 *p = read8(r)
28236         }
28237 }
28238
28239 func (obj *ModChanSig) serialize(w io.Writer) {
28240         {
28241                 x := *(*(uint8))(obj)
28242                 write8(w, uint8(x))
28243         }
28244 }
28245
28246 func (obj *ModChanSig) deserialize(r io.Reader) {
28247         {
28248                 p := &*(*(uint8))(obj)
28249                 *p = read8(r)
28250         }
28251 }
28252
28253 func (obj *AOProps) serialize(w io.Writer) {
28254         {
28255                 local330 := uint8(4)
28256                 {
28257                         x := local330
28258                         write8(w, uint8(x))
28259                 }
28260         }
28261         {
28262                 x := (*(*(struct {
28263                         MaxHP            uint16 // Player only.
28264                         CollideWithNodes bool
28265                         Weight           float32 // deprecated
28266                         ColBox, SelBox   Box
28267                         Pointable        bool
28268                         Visual           string
28269                         VisualSize       [3]float32
28270                         Textures         []Texture
28271                         SpriteSheetSize  [2]int16 // in sprites.
28272                         SpritePos        [2]int16 // in sprite sheet.
28273                         Visible          bool
28274                         MakeFootstepSnds bool
28275                         RotateSpeed      float32 // in radians per second.
28276                         Mesh             string
28277                         Colors           []color.NRGBA
28278                         CollideWithAOs   bool
28279                         StepHeight       float32
28280                         FaceRotateDir    bool
28281                         FaceRotateDirOff float32 // in degrees.
28282                         BackfaceCull     bool
28283                         Nametag          string
28284                         NametagColor     color.NRGBA
28285                         FaceRotateSpeed  float32 // in degrees per second.
28286                         Infotext         string
28287                         Itemstring       string
28288                         Glow             int8
28289                         MaxBreath        uint16  // Player only.
28290                         EyeHeight        float32 // Player only.
28291                         ZoomFOV          float32 // in degrees. Player only.
28292                         UseTextureAlpha  bool
28293                         DmgTextureMod    Texture // suffix
28294                         Shaded           bool
28295                         ShowOnMinimap    bool
28296                         NametagBG        color.NRGBA
28297                 }))(obj)).MaxHP
28298                 write16(w, uint16(x))
28299         }
28300         {
28301                 x := (*(*(struct {
28302                         MaxHP            uint16 // Player only.
28303                         CollideWithNodes bool
28304                         Weight           float32 // deprecated
28305                         ColBox, SelBox   Box
28306                         Pointable        bool
28307                         Visual           string
28308                         VisualSize       [3]float32
28309                         Textures         []Texture
28310                         SpriteSheetSize  [2]int16 // in sprites.
28311                         SpritePos        [2]int16 // in sprite sheet.
28312                         Visible          bool
28313                         MakeFootstepSnds bool
28314                         RotateSpeed      float32 // in radians per second.
28315                         Mesh             string
28316                         Colors           []color.NRGBA
28317                         CollideWithAOs   bool
28318                         StepHeight       float32
28319                         FaceRotateDir    bool
28320                         FaceRotateDirOff float32 // in degrees.
28321                         BackfaceCull     bool
28322                         Nametag          string
28323                         NametagColor     color.NRGBA
28324                         FaceRotateSpeed  float32 // in degrees per second.
28325                         Infotext         string
28326                         Itemstring       string
28327                         Glow             int8
28328                         MaxBreath        uint16  // Player only.
28329                         EyeHeight        float32 // Player only.
28330                         ZoomFOV          float32 // in degrees. Player only.
28331                         UseTextureAlpha  bool
28332                         DmgTextureMod    Texture // suffix
28333                         Shaded           bool
28334                         ShowOnMinimap    bool
28335                         NametagBG        color.NRGBA
28336                 }))(obj)).CollideWithNodes
28337                 if x {
28338                         write8(w, 1)
28339                 } else {
28340                         write8(w, 0)
28341                 }
28342         }
28343         {
28344                 x := (*(*(struct {
28345                         MaxHP            uint16 // Player only.
28346                         CollideWithNodes bool
28347                         Weight           float32 // deprecated
28348                         ColBox, SelBox   Box
28349                         Pointable        bool
28350                         Visual           string
28351                         VisualSize       [3]float32
28352                         Textures         []Texture
28353                         SpriteSheetSize  [2]int16 // in sprites.
28354                         SpritePos        [2]int16 // in sprite sheet.
28355                         Visible          bool
28356                         MakeFootstepSnds bool
28357                         RotateSpeed      float32 // in radians per second.
28358                         Mesh             string
28359                         Colors           []color.NRGBA
28360                         CollideWithAOs   bool
28361                         StepHeight       float32
28362                         FaceRotateDir    bool
28363                         FaceRotateDirOff float32 // in degrees.
28364                         BackfaceCull     bool
28365                         Nametag          string
28366                         NametagColor     color.NRGBA
28367                         FaceRotateSpeed  float32 // in degrees per second.
28368                         Infotext         string
28369                         Itemstring       string
28370                         Glow             int8
28371                         MaxBreath        uint16  // Player only.
28372                         EyeHeight        float32 // Player only.
28373                         ZoomFOV          float32 // in degrees. Player only.
28374                         UseTextureAlpha  bool
28375                         DmgTextureMod    Texture // suffix
28376                         Shaded           bool
28377                         ShowOnMinimap    bool
28378                         NametagBG        color.NRGBA
28379                 }))(obj)).Weight
28380                 write32(w, math.Float32bits(x))
28381         }
28382         if err := pcall(func() {
28383                 ((*(*(struct {
28384                         MaxHP            uint16 // Player only.
28385                         CollideWithNodes bool
28386                         Weight           float32 // deprecated
28387                         ColBox, SelBox   Box
28388                         Pointable        bool
28389                         Visual           string
28390                         VisualSize       [3]float32
28391                         Textures         []Texture
28392                         SpriteSheetSize  [2]int16 // in sprites.
28393                         SpritePos        [2]int16 // in sprite sheet.
28394                         Visible          bool
28395                         MakeFootstepSnds bool
28396                         RotateSpeed      float32 // in radians per second.
28397                         Mesh             string
28398                         Colors           []color.NRGBA
28399                         CollideWithAOs   bool
28400                         StepHeight       float32
28401                         FaceRotateDir    bool
28402                         FaceRotateDirOff float32 // in degrees.
28403                         BackfaceCull     bool
28404                         Nametag          string
28405                         NametagColor     color.NRGBA
28406                         FaceRotateSpeed  float32 // in degrees per second.
28407                         Infotext         string
28408                         Itemstring       string
28409                         Glow             int8
28410                         MaxBreath        uint16  // Player only.
28411                         EyeHeight        float32 // Player only.
28412                         ZoomFOV          float32 // in degrees. Player only.
28413                         UseTextureAlpha  bool
28414                         DmgTextureMod    Texture // suffix
28415                         Shaded           bool
28416                         ShowOnMinimap    bool
28417                         NametagBG        color.NRGBA
28418                 }))(obj)).ColBox).serialize(w)
28419         }); err != nil {
28420                 if err == io.EOF {
28421                         chk(io.EOF)
28422                 }
28423                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
28424         }
28425         if err := pcall(func() {
28426                 ((*(*(struct {
28427                         MaxHP            uint16 // Player only.
28428                         CollideWithNodes bool
28429                         Weight           float32 // deprecated
28430                         ColBox, SelBox   Box
28431                         Pointable        bool
28432                         Visual           string
28433                         VisualSize       [3]float32
28434                         Textures         []Texture
28435                         SpriteSheetSize  [2]int16 // in sprites.
28436                         SpritePos        [2]int16 // in sprite sheet.
28437                         Visible          bool
28438                         MakeFootstepSnds bool
28439                         RotateSpeed      float32 // in radians per second.
28440                         Mesh             string
28441                         Colors           []color.NRGBA
28442                         CollideWithAOs   bool
28443                         StepHeight       float32
28444                         FaceRotateDir    bool
28445                         FaceRotateDirOff float32 // in degrees.
28446                         BackfaceCull     bool
28447                         Nametag          string
28448                         NametagColor     color.NRGBA
28449                         FaceRotateSpeed  float32 // in degrees per second.
28450                         Infotext         string
28451                         Itemstring       string
28452                         Glow             int8
28453                         MaxBreath        uint16  // Player only.
28454                         EyeHeight        float32 // Player only.
28455                         ZoomFOV          float32 // in degrees. Player only.
28456                         UseTextureAlpha  bool
28457                         DmgTextureMod    Texture // suffix
28458                         Shaded           bool
28459                         ShowOnMinimap    bool
28460                         NametagBG        color.NRGBA
28461                 }))(obj)).SelBox).serialize(w)
28462         }); err != nil {
28463                 if err == io.EOF {
28464                         chk(io.EOF)
28465                 }
28466                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
28467         }
28468         {
28469                 x := (*(*(struct {
28470                         MaxHP            uint16 // Player only.
28471                         CollideWithNodes bool
28472                         Weight           float32 // deprecated
28473                         ColBox, SelBox   Box
28474                         Pointable        bool
28475                         Visual           string
28476                         VisualSize       [3]float32
28477                         Textures         []Texture
28478                         SpriteSheetSize  [2]int16 // in sprites.
28479                         SpritePos        [2]int16 // in sprite sheet.
28480                         Visible          bool
28481                         MakeFootstepSnds bool
28482                         RotateSpeed      float32 // in radians per second.
28483                         Mesh             string
28484                         Colors           []color.NRGBA
28485                         CollideWithAOs   bool
28486                         StepHeight       float32
28487                         FaceRotateDir    bool
28488                         FaceRotateDirOff float32 // in degrees.
28489                         BackfaceCull     bool
28490                         Nametag          string
28491                         NametagColor     color.NRGBA
28492                         FaceRotateSpeed  float32 // in degrees per second.
28493                         Infotext         string
28494                         Itemstring       string
28495                         Glow             int8
28496                         MaxBreath        uint16  // Player only.
28497                         EyeHeight        float32 // Player only.
28498                         ZoomFOV          float32 // in degrees. Player only.
28499                         UseTextureAlpha  bool
28500                         DmgTextureMod    Texture // suffix
28501                         Shaded           bool
28502                         ShowOnMinimap    bool
28503                         NametagBG        color.NRGBA
28504                 }))(obj)).Pointable
28505                 if x {
28506                         write8(w, 1)
28507                 } else {
28508                         write8(w, 0)
28509                 }
28510         }
28511         if len(([]byte((*(*(struct {
28512                 MaxHP            uint16 // Player only.
28513                 CollideWithNodes bool
28514                 Weight           float32 // deprecated
28515                 ColBox, SelBox   Box
28516                 Pointable        bool
28517                 Visual           string
28518                 VisualSize       [3]float32
28519                 Textures         []Texture
28520                 SpriteSheetSize  [2]int16 // in sprites.
28521                 SpritePos        [2]int16 // in sprite sheet.
28522                 Visible          bool
28523                 MakeFootstepSnds bool
28524                 RotateSpeed      float32 // in radians per second.
28525                 Mesh             string
28526                 Colors           []color.NRGBA
28527                 CollideWithAOs   bool
28528                 StepHeight       float32
28529                 FaceRotateDir    bool
28530                 FaceRotateDirOff float32 // in degrees.
28531                 BackfaceCull     bool
28532                 Nametag          string
28533                 NametagColor     color.NRGBA
28534                 FaceRotateSpeed  float32 // in degrees per second.
28535                 Infotext         string
28536                 Itemstring       string
28537                 Glow             int8
28538                 MaxBreath        uint16  // Player only.
28539                 EyeHeight        float32 // Player only.
28540                 ZoomFOV          float32 // in degrees. Player only.
28541                 UseTextureAlpha  bool
28542                 DmgTextureMod    Texture // suffix
28543                 Shaded           bool
28544                 ShowOnMinimap    bool
28545                 NametagBG        color.NRGBA
28546         }))(obj)).Visual))) > math.MaxUint16 {
28547                 chk(ErrTooLong)
28548         }
28549         {
28550                 x := uint16(len(([]byte((*(*(struct {
28551                         MaxHP            uint16 // Player only.
28552                         CollideWithNodes bool
28553                         Weight           float32 // deprecated
28554                         ColBox, SelBox   Box
28555                         Pointable        bool
28556                         Visual           string
28557                         VisualSize       [3]float32
28558                         Textures         []Texture
28559                         SpriteSheetSize  [2]int16 // in sprites.
28560                         SpritePos        [2]int16 // in sprite sheet.
28561                         Visible          bool
28562                         MakeFootstepSnds bool
28563                         RotateSpeed      float32 // in radians per second.
28564                         Mesh             string
28565                         Colors           []color.NRGBA
28566                         CollideWithAOs   bool
28567                         StepHeight       float32
28568                         FaceRotateDir    bool
28569                         FaceRotateDirOff float32 // in degrees.
28570                         BackfaceCull     bool
28571                         Nametag          string
28572                         NametagColor     color.NRGBA
28573                         FaceRotateSpeed  float32 // in degrees per second.
28574                         Infotext         string
28575                         Itemstring       string
28576                         Glow             int8
28577                         MaxBreath        uint16  // Player only.
28578                         EyeHeight        float32 // Player only.
28579                         ZoomFOV          float32 // in degrees. Player only.
28580                         UseTextureAlpha  bool
28581                         DmgTextureMod    Texture // suffix
28582                         Shaded           bool
28583                         ShowOnMinimap    bool
28584                         NametagBG        color.NRGBA
28585                 }))(obj)).Visual))))
28586                 write16(w, uint16(x))
28587         }
28588         {
28589                 _, err := w.Write(([]byte((*(*(struct {
28590                         MaxHP            uint16 // Player only.
28591                         CollideWithNodes bool
28592                         Weight           float32 // deprecated
28593                         ColBox, SelBox   Box
28594                         Pointable        bool
28595                         Visual           string
28596                         VisualSize       [3]float32
28597                         Textures         []Texture
28598                         SpriteSheetSize  [2]int16 // in sprites.
28599                         SpritePos        [2]int16 // in sprite sheet.
28600                         Visible          bool
28601                         MakeFootstepSnds bool
28602                         RotateSpeed      float32 // in radians per second.
28603                         Mesh             string
28604                         Colors           []color.NRGBA
28605                         CollideWithAOs   bool
28606                         StepHeight       float32
28607                         FaceRotateDir    bool
28608                         FaceRotateDirOff float32 // in degrees.
28609                         BackfaceCull     bool
28610                         Nametag          string
28611                         NametagColor     color.NRGBA
28612                         FaceRotateSpeed  float32 // in degrees per second.
28613                         Infotext         string
28614                         Itemstring       string
28615                         Glow             int8
28616                         MaxBreath        uint16  // Player only.
28617                         EyeHeight        float32 // Player only.
28618                         ZoomFOV          float32 // in degrees. Player only.
28619                         UseTextureAlpha  bool
28620                         DmgTextureMod    Texture // suffix
28621                         Shaded           bool
28622                         ShowOnMinimap    bool
28623                         NametagBG        color.NRGBA
28624                 }))(obj)).Visual))[:])
28625                 chk(err)
28626         }
28627         for local331 := range (*(*(struct {
28628                 MaxHP            uint16 // Player only.
28629                 CollideWithNodes bool
28630                 Weight           float32 // deprecated
28631                 ColBox, SelBox   Box
28632                 Pointable        bool
28633                 Visual           string
28634                 VisualSize       [3]float32
28635                 Textures         []Texture
28636                 SpriteSheetSize  [2]int16 // in sprites.
28637                 SpritePos        [2]int16 // in sprite sheet.
28638                 Visible          bool
28639                 MakeFootstepSnds bool
28640                 RotateSpeed      float32 // in radians per second.
28641                 Mesh             string
28642                 Colors           []color.NRGBA
28643                 CollideWithAOs   bool
28644                 StepHeight       float32
28645                 FaceRotateDir    bool
28646                 FaceRotateDirOff float32 // in degrees.
28647                 BackfaceCull     bool
28648                 Nametag          string
28649                 NametagColor     color.NRGBA
28650                 FaceRotateSpeed  float32 // in degrees per second.
28651                 Infotext         string
28652                 Itemstring       string
28653                 Glow             int8
28654                 MaxBreath        uint16  // Player only.
28655                 EyeHeight        float32 // Player only.
28656                 ZoomFOV          float32 // in degrees. Player only.
28657                 UseTextureAlpha  bool
28658                 DmgTextureMod    Texture // suffix
28659                 Shaded           bool
28660                 ShowOnMinimap    bool
28661                 NametagBG        color.NRGBA
28662         }))(obj)).VisualSize {
28663                 {
28664                         x := ((*(*(struct {
28665                                 MaxHP            uint16 // Player only.
28666                                 CollideWithNodes bool
28667                                 Weight           float32 // deprecated
28668                                 ColBox, SelBox   Box
28669                                 Pointable        bool
28670                                 Visual           string
28671                                 VisualSize       [3]float32
28672                                 Textures         []Texture
28673                                 SpriteSheetSize  [2]int16 // in sprites.
28674                                 SpritePos        [2]int16 // in sprite sheet.
28675                                 Visible          bool
28676                                 MakeFootstepSnds bool
28677                                 RotateSpeed      float32 // in radians per second.
28678                                 Mesh             string
28679                                 Colors           []color.NRGBA
28680                                 CollideWithAOs   bool
28681                                 StepHeight       float32
28682                                 FaceRotateDir    bool
28683                                 FaceRotateDirOff float32 // in degrees.
28684                                 BackfaceCull     bool
28685                                 Nametag          string
28686                                 NametagColor     color.NRGBA
28687                                 FaceRotateSpeed  float32 // in degrees per second.
28688                                 Infotext         string
28689                                 Itemstring       string
28690                                 Glow             int8
28691                                 MaxBreath        uint16  // Player only.
28692                                 EyeHeight        float32 // Player only.
28693                                 ZoomFOV          float32 // in degrees. Player only.
28694                                 UseTextureAlpha  bool
28695                                 DmgTextureMod    Texture // suffix
28696                                 Shaded           bool
28697                                 ShowOnMinimap    bool
28698                                 NametagBG        color.NRGBA
28699                         }))(obj)).VisualSize)[local331]
28700                         write32(w, math.Float32bits(x))
28701                 }
28702         }
28703         if len(((*(*(struct {
28704                 MaxHP            uint16 // Player only.
28705                 CollideWithNodes bool
28706                 Weight           float32 // deprecated
28707                 ColBox, SelBox   Box
28708                 Pointable        bool
28709                 Visual           string
28710                 VisualSize       [3]float32
28711                 Textures         []Texture
28712                 SpriteSheetSize  [2]int16 // in sprites.
28713                 SpritePos        [2]int16 // in sprite sheet.
28714                 Visible          bool
28715                 MakeFootstepSnds bool
28716                 RotateSpeed      float32 // in radians per second.
28717                 Mesh             string
28718                 Colors           []color.NRGBA
28719                 CollideWithAOs   bool
28720                 StepHeight       float32
28721                 FaceRotateDir    bool
28722                 FaceRotateDirOff float32 // in degrees.
28723                 BackfaceCull     bool
28724                 Nametag          string
28725                 NametagColor     color.NRGBA
28726                 FaceRotateSpeed  float32 // in degrees per second.
28727                 Infotext         string
28728                 Itemstring       string
28729                 Glow             int8
28730                 MaxBreath        uint16  // Player only.
28731                 EyeHeight        float32 // Player only.
28732                 ZoomFOV          float32 // in degrees. Player only.
28733                 UseTextureAlpha  bool
28734                 DmgTextureMod    Texture // suffix
28735                 Shaded           bool
28736                 ShowOnMinimap    bool
28737                 NametagBG        color.NRGBA
28738         }))(obj)).Textures)) > math.MaxUint16 {
28739                 chk(ErrTooLong)
28740         }
28741         {
28742                 x := uint16(len(((*(*(struct {
28743                         MaxHP            uint16 // Player only.
28744                         CollideWithNodes bool
28745                         Weight           float32 // deprecated
28746                         ColBox, SelBox   Box
28747                         Pointable        bool
28748                         Visual           string
28749                         VisualSize       [3]float32
28750                         Textures         []Texture
28751                         SpriteSheetSize  [2]int16 // in sprites.
28752                         SpritePos        [2]int16 // in sprite sheet.
28753                         Visible          bool
28754                         MakeFootstepSnds bool
28755                         RotateSpeed      float32 // in radians per second.
28756                         Mesh             string
28757                         Colors           []color.NRGBA
28758                         CollideWithAOs   bool
28759                         StepHeight       float32
28760                         FaceRotateDir    bool
28761                         FaceRotateDirOff float32 // in degrees.
28762                         BackfaceCull     bool
28763                         Nametag          string
28764                         NametagColor     color.NRGBA
28765                         FaceRotateSpeed  float32 // in degrees per second.
28766                         Infotext         string
28767                         Itemstring       string
28768                         Glow             int8
28769                         MaxBreath        uint16  // Player only.
28770                         EyeHeight        float32 // Player only.
28771                         ZoomFOV          float32 // in degrees. Player only.
28772                         UseTextureAlpha  bool
28773                         DmgTextureMod    Texture // suffix
28774                         Shaded           bool
28775                         ShowOnMinimap    bool
28776                         NametagBG        color.NRGBA
28777                 }))(obj)).Textures)))
28778                 write16(w, uint16(x))
28779         }
28780         for local332 := range (*(*(struct {
28781                 MaxHP            uint16 // Player only.
28782                 CollideWithNodes bool
28783                 Weight           float32 // deprecated
28784                 ColBox, SelBox   Box
28785                 Pointable        bool
28786                 Visual           string
28787                 VisualSize       [3]float32
28788                 Textures         []Texture
28789                 SpriteSheetSize  [2]int16 // in sprites.
28790                 SpritePos        [2]int16 // in sprite sheet.
28791                 Visible          bool
28792                 MakeFootstepSnds bool
28793                 RotateSpeed      float32 // in radians per second.
28794                 Mesh             string
28795                 Colors           []color.NRGBA
28796                 CollideWithAOs   bool
28797                 StepHeight       float32
28798                 FaceRotateDir    bool
28799                 FaceRotateDirOff float32 // in degrees.
28800                 BackfaceCull     bool
28801                 Nametag          string
28802                 NametagColor     color.NRGBA
28803                 FaceRotateSpeed  float32 // in degrees per second.
28804                 Infotext         string
28805                 Itemstring       string
28806                 Glow             int8
28807                 MaxBreath        uint16  // Player only.
28808                 EyeHeight        float32 // Player only.
28809                 ZoomFOV          float32 // in degrees. Player only.
28810                 UseTextureAlpha  bool
28811                 DmgTextureMod    Texture // suffix
28812                 Shaded           bool
28813                 ShowOnMinimap    bool
28814                 NametagBG        color.NRGBA
28815         }))(obj)).Textures {
28816                 if err := pcall(func() {
28817                         (((*(*(struct {
28818                                 MaxHP            uint16 // Player only.
28819                                 CollideWithNodes bool
28820                                 Weight           float32 // deprecated
28821                                 ColBox, SelBox   Box
28822                                 Pointable        bool
28823                                 Visual           string
28824                                 VisualSize       [3]float32
28825                                 Textures         []Texture
28826                                 SpriteSheetSize  [2]int16 // in sprites.
28827                                 SpritePos        [2]int16 // in sprite sheet.
28828                                 Visible          bool
28829                                 MakeFootstepSnds bool
28830                                 RotateSpeed      float32 // in radians per second.
28831                                 Mesh             string
28832                                 Colors           []color.NRGBA
28833                                 CollideWithAOs   bool
28834                                 StepHeight       float32
28835                                 FaceRotateDir    bool
28836                                 FaceRotateDirOff float32 // in degrees.
28837                                 BackfaceCull     bool
28838                                 Nametag          string
28839                                 NametagColor     color.NRGBA
28840                                 FaceRotateSpeed  float32 // in degrees per second.
28841                                 Infotext         string
28842                                 Itemstring       string
28843                                 Glow             int8
28844                                 MaxBreath        uint16  // Player only.
28845                                 EyeHeight        float32 // Player only.
28846                                 ZoomFOV          float32 // in degrees. Player only.
28847                                 UseTextureAlpha  bool
28848                                 DmgTextureMod    Texture // suffix
28849                                 Shaded           bool
28850                                 ShowOnMinimap    bool
28851                                 NametagBG        color.NRGBA
28852                         }))(obj)).Textures)[local332]).serialize(w)
28853                 }); err != nil {
28854                         if err == io.EOF {
28855                                 chk(io.EOF)
28856                         }
28857                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
28858                 }
28859         }
28860         for local333 := range (*(*(struct {
28861                 MaxHP            uint16 // Player only.
28862                 CollideWithNodes bool
28863                 Weight           float32 // deprecated
28864                 ColBox, SelBox   Box
28865                 Pointable        bool
28866                 Visual           string
28867                 VisualSize       [3]float32
28868                 Textures         []Texture
28869                 SpriteSheetSize  [2]int16 // in sprites.
28870                 SpritePos        [2]int16 // in sprite sheet.
28871                 Visible          bool
28872                 MakeFootstepSnds bool
28873                 RotateSpeed      float32 // in radians per second.
28874                 Mesh             string
28875                 Colors           []color.NRGBA
28876                 CollideWithAOs   bool
28877                 StepHeight       float32
28878                 FaceRotateDir    bool
28879                 FaceRotateDirOff float32 // in degrees.
28880                 BackfaceCull     bool
28881                 Nametag          string
28882                 NametagColor     color.NRGBA
28883                 FaceRotateSpeed  float32 // in degrees per second.
28884                 Infotext         string
28885                 Itemstring       string
28886                 Glow             int8
28887                 MaxBreath        uint16  // Player only.
28888                 EyeHeight        float32 // Player only.
28889                 ZoomFOV          float32 // in degrees. Player only.
28890                 UseTextureAlpha  bool
28891                 DmgTextureMod    Texture // suffix
28892                 Shaded           bool
28893                 ShowOnMinimap    bool
28894                 NametagBG        color.NRGBA
28895         }))(obj)).SpriteSheetSize {
28896                 {
28897                         x := ((*(*(struct {
28898                                 MaxHP            uint16 // Player only.
28899                                 CollideWithNodes bool
28900                                 Weight           float32 // deprecated
28901                                 ColBox, SelBox   Box
28902                                 Pointable        bool
28903                                 Visual           string
28904                                 VisualSize       [3]float32
28905                                 Textures         []Texture
28906                                 SpriteSheetSize  [2]int16 // in sprites.
28907                                 SpritePos        [2]int16 // in sprite sheet.
28908                                 Visible          bool
28909                                 MakeFootstepSnds bool
28910                                 RotateSpeed      float32 // in radians per second.
28911                                 Mesh             string
28912                                 Colors           []color.NRGBA
28913                                 CollideWithAOs   bool
28914                                 StepHeight       float32
28915                                 FaceRotateDir    bool
28916                                 FaceRotateDirOff float32 // in degrees.
28917                                 BackfaceCull     bool
28918                                 Nametag          string
28919                                 NametagColor     color.NRGBA
28920                                 FaceRotateSpeed  float32 // in degrees per second.
28921                                 Infotext         string
28922                                 Itemstring       string
28923                                 Glow             int8
28924                                 MaxBreath        uint16  // Player only.
28925                                 EyeHeight        float32 // Player only.
28926                                 ZoomFOV          float32 // in degrees. Player only.
28927                                 UseTextureAlpha  bool
28928                                 DmgTextureMod    Texture // suffix
28929                                 Shaded           bool
28930                                 ShowOnMinimap    bool
28931                                 NametagBG        color.NRGBA
28932                         }))(obj)).SpriteSheetSize)[local333]
28933                         write16(w, uint16(x))
28934                 }
28935         }
28936         for local334 := range (*(*(struct {
28937                 MaxHP            uint16 // Player only.
28938                 CollideWithNodes bool
28939                 Weight           float32 // deprecated
28940                 ColBox, SelBox   Box
28941                 Pointable        bool
28942                 Visual           string
28943                 VisualSize       [3]float32
28944                 Textures         []Texture
28945                 SpriteSheetSize  [2]int16 // in sprites.
28946                 SpritePos        [2]int16 // in sprite sheet.
28947                 Visible          bool
28948                 MakeFootstepSnds bool
28949                 RotateSpeed      float32 // in radians per second.
28950                 Mesh             string
28951                 Colors           []color.NRGBA
28952                 CollideWithAOs   bool
28953                 StepHeight       float32
28954                 FaceRotateDir    bool
28955                 FaceRotateDirOff float32 // in degrees.
28956                 BackfaceCull     bool
28957                 Nametag          string
28958                 NametagColor     color.NRGBA
28959                 FaceRotateSpeed  float32 // in degrees per second.
28960                 Infotext         string
28961                 Itemstring       string
28962                 Glow             int8
28963                 MaxBreath        uint16  // Player only.
28964                 EyeHeight        float32 // Player only.
28965                 ZoomFOV          float32 // in degrees. Player only.
28966                 UseTextureAlpha  bool
28967                 DmgTextureMod    Texture // suffix
28968                 Shaded           bool
28969                 ShowOnMinimap    bool
28970                 NametagBG        color.NRGBA
28971         }))(obj)).SpritePos {
28972                 {
28973                         x := ((*(*(struct {
28974                                 MaxHP            uint16 // Player only.
28975                                 CollideWithNodes bool
28976                                 Weight           float32 // deprecated
28977                                 ColBox, SelBox   Box
28978                                 Pointable        bool
28979                                 Visual           string
28980                                 VisualSize       [3]float32
28981                                 Textures         []Texture
28982                                 SpriteSheetSize  [2]int16 // in sprites.
28983                                 SpritePos        [2]int16 // in sprite sheet.
28984                                 Visible          bool
28985                                 MakeFootstepSnds bool
28986                                 RotateSpeed      float32 // in radians per second.
28987                                 Mesh             string
28988                                 Colors           []color.NRGBA
28989                                 CollideWithAOs   bool
28990                                 StepHeight       float32
28991                                 FaceRotateDir    bool
28992                                 FaceRotateDirOff float32 // in degrees.
28993                                 BackfaceCull     bool
28994                                 Nametag          string
28995                                 NametagColor     color.NRGBA
28996                                 FaceRotateSpeed  float32 // in degrees per second.
28997                                 Infotext         string
28998                                 Itemstring       string
28999                                 Glow             int8
29000                                 MaxBreath        uint16  // Player only.
29001                                 EyeHeight        float32 // Player only.
29002                                 ZoomFOV          float32 // in degrees. Player only.
29003                                 UseTextureAlpha  bool
29004                                 DmgTextureMod    Texture // suffix
29005                                 Shaded           bool
29006                                 ShowOnMinimap    bool
29007                                 NametagBG        color.NRGBA
29008                         }))(obj)).SpritePos)[local334]
29009                         write16(w, uint16(x))
29010                 }
29011         }
29012         {
29013                 x := (*(*(struct {
29014                         MaxHP            uint16 // Player only.
29015                         CollideWithNodes bool
29016                         Weight           float32 // deprecated
29017                         ColBox, SelBox   Box
29018                         Pointable        bool
29019                         Visual           string
29020                         VisualSize       [3]float32
29021                         Textures         []Texture
29022                         SpriteSheetSize  [2]int16 // in sprites.
29023                         SpritePos        [2]int16 // in sprite sheet.
29024                         Visible          bool
29025                         MakeFootstepSnds bool
29026                         RotateSpeed      float32 // in radians per second.
29027                         Mesh             string
29028                         Colors           []color.NRGBA
29029                         CollideWithAOs   bool
29030                         StepHeight       float32
29031                         FaceRotateDir    bool
29032                         FaceRotateDirOff float32 // in degrees.
29033                         BackfaceCull     bool
29034                         Nametag          string
29035                         NametagColor     color.NRGBA
29036                         FaceRotateSpeed  float32 // in degrees per second.
29037                         Infotext         string
29038                         Itemstring       string
29039                         Glow             int8
29040                         MaxBreath        uint16  // Player only.
29041                         EyeHeight        float32 // Player only.
29042                         ZoomFOV          float32 // in degrees. Player only.
29043                         UseTextureAlpha  bool
29044                         DmgTextureMod    Texture // suffix
29045                         Shaded           bool
29046                         ShowOnMinimap    bool
29047                         NametagBG        color.NRGBA
29048                 }))(obj)).Visible
29049                 if x {
29050                         write8(w, 1)
29051                 } else {
29052                         write8(w, 0)
29053                 }
29054         }
29055         {
29056                 x := (*(*(struct {
29057                         MaxHP            uint16 // Player only.
29058                         CollideWithNodes bool
29059                         Weight           float32 // deprecated
29060                         ColBox, SelBox   Box
29061                         Pointable        bool
29062                         Visual           string
29063                         VisualSize       [3]float32
29064                         Textures         []Texture
29065                         SpriteSheetSize  [2]int16 // in sprites.
29066                         SpritePos        [2]int16 // in sprite sheet.
29067                         Visible          bool
29068                         MakeFootstepSnds bool
29069                         RotateSpeed      float32 // in radians per second.
29070                         Mesh             string
29071                         Colors           []color.NRGBA
29072                         CollideWithAOs   bool
29073                         StepHeight       float32
29074                         FaceRotateDir    bool
29075                         FaceRotateDirOff float32 // in degrees.
29076                         BackfaceCull     bool
29077                         Nametag          string
29078                         NametagColor     color.NRGBA
29079                         FaceRotateSpeed  float32 // in degrees per second.
29080                         Infotext         string
29081                         Itemstring       string
29082                         Glow             int8
29083                         MaxBreath        uint16  // Player only.
29084                         EyeHeight        float32 // Player only.
29085                         ZoomFOV          float32 // in degrees. Player only.
29086                         UseTextureAlpha  bool
29087                         DmgTextureMod    Texture // suffix
29088                         Shaded           bool
29089                         ShowOnMinimap    bool
29090                         NametagBG        color.NRGBA
29091                 }))(obj)).MakeFootstepSnds
29092                 if x {
29093                         write8(w, 1)
29094                 } else {
29095                         write8(w, 0)
29096                 }
29097         }
29098         {
29099                 x := (*(*(struct {
29100                         MaxHP            uint16 // Player only.
29101                         CollideWithNodes bool
29102                         Weight           float32 // deprecated
29103                         ColBox, SelBox   Box
29104                         Pointable        bool
29105                         Visual           string
29106                         VisualSize       [3]float32
29107                         Textures         []Texture
29108                         SpriteSheetSize  [2]int16 // in sprites.
29109                         SpritePos        [2]int16 // in sprite sheet.
29110                         Visible          bool
29111                         MakeFootstepSnds bool
29112                         RotateSpeed      float32 // in radians per second.
29113                         Mesh             string
29114                         Colors           []color.NRGBA
29115                         CollideWithAOs   bool
29116                         StepHeight       float32
29117                         FaceRotateDir    bool
29118                         FaceRotateDirOff float32 // in degrees.
29119                         BackfaceCull     bool
29120                         Nametag          string
29121                         NametagColor     color.NRGBA
29122                         FaceRotateSpeed  float32 // in degrees per second.
29123                         Infotext         string
29124                         Itemstring       string
29125                         Glow             int8
29126                         MaxBreath        uint16  // Player only.
29127                         EyeHeight        float32 // Player only.
29128                         ZoomFOV          float32 // in degrees. Player only.
29129                         UseTextureAlpha  bool
29130                         DmgTextureMod    Texture // suffix
29131                         Shaded           bool
29132                         ShowOnMinimap    bool
29133                         NametagBG        color.NRGBA
29134                 }))(obj)).RotateSpeed
29135                 write32(w, math.Float32bits(x))
29136         }
29137         if len(([]byte((*(*(struct {
29138                 MaxHP            uint16 // Player only.
29139                 CollideWithNodes bool
29140                 Weight           float32 // deprecated
29141                 ColBox, SelBox   Box
29142                 Pointable        bool
29143                 Visual           string
29144                 VisualSize       [3]float32
29145                 Textures         []Texture
29146                 SpriteSheetSize  [2]int16 // in sprites.
29147                 SpritePos        [2]int16 // in sprite sheet.
29148                 Visible          bool
29149                 MakeFootstepSnds bool
29150                 RotateSpeed      float32 // in radians per second.
29151                 Mesh             string
29152                 Colors           []color.NRGBA
29153                 CollideWithAOs   bool
29154                 StepHeight       float32
29155                 FaceRotateDir    bool
29156                 FaceRotateDirOff float32 // in degrees.
29157                 BackfaceCull     bool
29158                 Nametag          string
29159                 NametagColor     color.NRGBA
29160                 FaceRotateSpeed  float32 // in degrees per second.
29161                 Infotext         string
29162                 Itemstring       string
29163                 Glow             int8
29164                 MaxBreath        uint16  // Player only.
29165                 EyeHeight        float32 // Player only.
29166                 ZoomFOV          float32 // in degrees. Player only.
29167                 UseTextureAlpha  bool
29168                 DmgTextureMod    Texture // suffix
29169                 Shaded           bool
29170                 ShowOnMinimap    bool
29171                 NametagBG        color.NRGBA
29172         }))(obj)).Mesh))) > math.MaxUint16 {
29173                 chk(ErrTooLong)
29174         }
29175         {
29176                 x := uint16(len(([]byte((*(*(struct {
29177                         MaxHP            uint16 // Player only.
29178                         CollideWithNodes bool
29179                         Weight           float32 // deprecated
29180                         ColBox, SelBox   Box
29181                         Pointable        bool
29182                         Visual           string
29183                         VisualSize       [3]float32
29184                         Textures         []Texture
29185                         SpriteSheetSize  [2]int16 // in sprites.
29186                         SpritePos        [2]int16 // in sprite sheet.
29187                         Visible          bool
29188                         MakeFootstepSnds bool
29189                         RotateSpeed      float32 // in radians per second.
29190                         Mesh             string
29191                         Colors           []color.NRGBA
29192                         CollideWithAOs   bool
29193                         StepHeight       float32
29194                         FaceRotateDir    bool
29195                         FaceRotateDirOff float32 // in degrees.
29196                         BackfaceCull     bool
29197                         Nametag          string
29198                         NametagColor     color.NRGBA
29199                         FaceRotateSpeed  float32 // in degrees per second.
29200                         Infotext         string
29201                         Itemstring       string
29202                         Glow             int8
29203                         MaxBreath        uint16  // Player only.
29204                         EyeHeight        float32 // Player only.
29205                         ZoomFOV          float32 // in degrees. Player only.
29206                         UseTextureAlpha  bool
29207                         DmgTextureMod    Texture // suffix
29208                         Shaded           bool
29209                         ShowOnMinimap    bool
29210                         NametagBG        color.NRGBA
29211                 }))(obj)).Mesh))))
29212                 write16(w, uint16(x))
29213         }
29214         {
29215                 _, err := w.Write(([]byte((*(*(struct {
29216                         MaxHP            uint16 // Player only.
29217                         CollideWithNodes bool
29218                         Weight           float32 // deprecated
29219                         ColBox, SelBox   Box
29220                         Pointable        bool
29221                         Visual           string
29222                         VisualSize       [3]float32
29223                         Textures         []Texture
29224                         SpriteSheetSize  [2]int16 // in sprites.
29225                         SpritePos        [2]int16 // in sprite sheet.
29226                         Visible          bool
29227                         MakeFootstepSnds bool
29228                         RotateSpeed      float32 // in radians per second.
29229                         Mesh             string
29230                         Colors           []color.NRGBA
29231                         CollideWithAOs   bool
29232                         StepHeight       float32
29233                         FaceRotateDir    bool
29234                         FaceRotateDirOff float32 // in degrees.
29235                         BackfaceCull     bool
29236                         Nametag          string
29237                         NametagColor     color.NRGBA
29238                         FaceRotateSpeed  float32 // in degrees per second.
29239                         Infotext         string
29240                         Itemstring       string
29241                         Glow             int8
29242                         MaxBreath        uint16  // Player only.
29243                         EyeHeight        float32 // Player only.
29244                         ZoomFOV          float32 // in degrees. Player only.
29245                         UseTextureAlpha  bool
29246                         DmgTextureMod    Texture // suffix
29247                         Shaded           bool
29248                         ShowOnMinimap    bool
29249                         NametagBG        color.NRGBA
29250                 }))(obj)).Mesh))[:])
29251                 chk(err)
29252         }
29253         if len(((*(*(struct {
29254                 MaxHP            uint16 // Player only.
29255                 CollideWithNodes bool
29256                 Weight           float32 // deprecated
29257                 ColBox, SelBox   Box
29258                 Pointable        bool
29259                 Visual           string
29260                 VisualSize       [3]float32
29261                 Textures         []Texture
29262                 SpriteSheetSize  [2]int16 // in sprites.
29263                 SpritePos        [2]int16 // in sprite sheet.
29264                 Visible          bool
29265                 MakeFootstepSnds bool
29266                 RotateSpeed      float32 // in radians per second.
29267                 Mesh             string
29268                 Colors           []color.NRGBA
29269                 CollideWithAOs   bool
29270                 StepHeight       float32
29271                 FaceRotateDir    bool
29272                 FaceRotateDirOff float32 // in degrees.
29273                 BackfaceCull     bool
29274                 Nametag          string
29275                 NametagColor     color.NRGBA
29276                 FaceRotateSpeed  float32 // in degrees per second.
29277                 Infotext         string
29278                 Itemstring       string
29279                 Glow             int8
29280                 MaxBreath        uint16  // Player only.
29281                 EyeHeight        float32 // Player only.
29282                 ZoomFOV          float32 // in degrees. Player only.
29283                 UseTextureAlpha  bool
29284                 DmgTextureMod    Texture // suffix
29285                 Shaded           bool
29286                 ShowOnMinimap    bool
29287                 NametagBG        color.NRGBA
29288         }))(obj)).Colors)) > math.MaxUint16 {
29289                 chk(ErrTooLong)
29290         }
29291         {
29292                 x := uint16(len(((*(*(struct {
29293                         MaxHP            uint16 // Player only.
29294                         CollideWithNodes bool
29295                         Weight           float32 // deprecated
29296                         ColBox, SelBox   Box
29297                         Pointable        bool
29298                         Visual           string
29299                         VisualSize       [3]float32
29300                         Textures         []Texture
29301                         SpriteSheetSize  [2]int16 // in sprites.
29302                         SpritePos        [2]int16 // in sprite sheet.
29303                         Visible          bool
29304                         MakeFootstepSnds bool
29305                         RotateSpeed      float32 // in radians per second.
29306                         Mesh             string
29307                         Colors           []color.NRGBA
29308                         CollideWithAOs   bool
29309                         StepHeight       float32
29310                         FaceRotateDir    bool
29311                         FaceRotateDirOff float32 // in degrees.
29312                         BackfaceCull     bool
29313                         Nametag          string
29314                         NametagColor     color.NRGBA
29315                         FaceRotateSpeed  float32 // in degrees per second.
29316                         Infotext         string
29317                         Itemstring       string
29318                         Glow             int8
29319                         MaxBreath        uint16  // Player only.
29320                         EyeHeight        float32 // Player only.
29321                         ZoomFOV          float32 // in degrees. Player only.
29322                         UseTextureAlpha  bool
29323                         DmgTextureMod    Texture // suffix
29324                         Shaded           bool
29325                         ShowOnMinimap    bool
29326                         NametagBG        color.NRGBA
29327                 }))(obj)).Colors)))
29328                 write16(w, uint16(x))
29329         }
29330         for local335 := range (*(*(struct {
29331                 MaxHP            uint16 // Player only.
29332                 CollideWithNodes bool
29333                 Weight           float32 // deprecated
29334                 ColBox, SelBox   Box
29335                 Pointable        bool
29336                 Visual           string
29337                 VisualSize       [3]float32
29338                 Textures         []Texture
29339                 SpriteSheetSize  [2]int16 // in sprites.
29340                 SpritePos        [2]int16 // in sprite sheet.
29341                 Visible          bool
29342                 MakeFootstepSnds bool
29343                 RotateSpeed      float32 // in radians per second.
29344                 Mesh             string
29345                 Colors           []color.NRGBA
29346                 CollideWithAOs   bool
29347                 StepHeight       float32
29348                 FaceRotateDir    bool
29349                 FaceRotateDirOff float32 // in degrees.
29350                 BackfaceCull     bool
29351                 Nametag          string
29352                 NametagColor     color.NRGBA
29353                 FaceRotateSpeed  float32 // in degrees per second.
29354                 Infotext         string
29355                 Itemstring       string
29356                 Glow             int8
29357                 MaxBreath        uint16  // Player only.
29358                 EyeHeight        float32 // Player only.
29359                 ZoomFOV          float32 // in degrees. Player only.
29360                 UseTextureAlpha  bool
29361                 DmgTextureMod    Texture // suffix
29362                 Shaded           bool
29363                 ShowOnMinimap    bool
29364                 NametagBG        color.NRGBA
29365         }))(obj)).Colors {
29366                 {
29367                         x := ((*(*(struct {
29368                                 MaxHP            uint16 // Player only.
29369                                 CollideWithNodes bool
29370                                 Weight           float32 // deprecated
29371                                 ColBox, SelBox   Box
29372                                 Pointable        bool
29373                                 Visual           string
29374                                 VisualSize       [3]float32
29375                                 Textures         []Texture
29376                                 SpriteSheetSize  [2]int16 // in sprites.
29377                                 SpritePos        [2]int16 // in sprite sheet.
29378                                 Visible          bool
29379                                 MakeFootstepSnds bool
29380                                 RotateSpeed      float32 // in radians per second.
29381                                 Mesh             string
29382                                 Colors           []color.NRGBA
29383                                 CollideWithAOs   bool
29384                                 StepHeight       float32
29385                                 FaceRotateDir    bool
29386                                 FaceRotateDirOff float32 // in degrees.
29387                                 BackfaceCull     bool
29388                                 Nametag          string
29389                                 NametagColor     color.NRGBA
29390                                 FaceRotateSpeed  float32 // in degrees per second.
29391                                 Infotext         string
29392                                 Itemstring       string
29393                                 Glow             int8
29394                                 MaxBreath        uint16  // Player only.
29395                                 EyeHeight        float32 // Player only.
29396                                 ZoomFOV          float32 // in degrees. Player only.
29397                                 UseTextureAlpha  bool
29398                                 DmgTextureMod    Texture // suffix
29399                                 Shaded           bool
29400                                 ShowOnMinimap    bool
29401                                 NametagBG        color.NRGBA
29402                         }))(obj)).Colors)[local335]
29403                         w.Write([]byte{x.A, x.R, x.G, x.B})
29404                 }
29405         }
29406         {
29407                 x := (*(*(struct {
29408                         MaxHP            uint16 // Player only.
29409                         CollideWithNodes bool
29410                         Weight           float32 // deprecated
29411                         ColBox, SelBox   Box
29412                         Pointable        bool
29413                         Visual           string
29414                         VisualSize       [3]float32
29415                         Textures         []Texture
29416                         SpriteSheetSize  [2]int16 // in sprites.
29417                         SpritePos        [2]int16 // in sprite sheet.
29418                         Visible          bool
29419                         MakeFootstepSnds bool
29420                         RotateSpeed      float32 // in radians per second.
29421                         Mesh             string
29422                         Colors           []color.NRGBA
29423                         CollideWithAOs   bool
29424                         StepHeight       float32
29425                         FaceRotateDir    bool
29426                         FaceRotateDirOff float32 // in degrees.
29427                         BackfaceCull     bool
29428                         Nametag          string
29429                         NametagColor     color.NRGBA
29430                         FaceRotateSpeed  float32 // in degrees per second.
29431                         Infotext         string
29432                         Itemstring       string
29433                         Glow             int8
29434                         MaxBreath        uint16  // Player only.
29435                         EyeHeight        float32 // Player only.
29436                         ZoomFOV          float32 // in degrees. Player only.
29437                         UseTextureAlpha  bool
29438                         DmgTextureMod    Texture // suffix
29439                         Shaded           bool
29440                         ShowOnMinimap    bool
29441                         NametagBG        color.NRGBA
29442                 }))(obj)).CollideWithAOs
29443                 if x {
29444                         write8(w, 1)
29445                 } else {
29446                         write8(w, 0)
29447                 }
29448         }
29449         {
29450                 x := (*(*(struct {
29451                         MaxHP            uint16 // Player only.
29452                         CollideWithNodes bool
29453                         Weight           float32 // deprecated
29454                         ColBox, SelBox   Box
29455                         Pointable        bool
29456                         Visual           string
29457                         VisualSize       [3]float32
29458                         Textures         []Texture
29459                         SpriteSheetSize  [2]int16 // in sprites.
29460                         SpritePos        [2]int16 // in sprite sheet.
29461                         Visible          bool
29462                         MakeFootstepSnds bool
29463                         RotateSpeed      float32 // in radians per second.
29464                         Mesh             string
29465                         Colors           []color.NRGBA
29466                         CollideWithAOs   bool
29467                         StepHeight       float32
29468                         FaceRotateDir    bool
29469                         FaceRotateDirOff float32 // in degrees.
29470                         BackfaceCull     bool
29471                         Nametag          string
29472                         NametagColor     color.NRGBA
29473                         FaceRotateSpeed  float32 // in degrees per second.
29474                         Infotext         string
29475                         Itemstring       string
29476                         Glow             int8
29477                         MaxBreath        uint16  // Player only.
29478                         EyeHeight        float32 // Player only.
29479                         ZoomFOV          float32 // in degrees. Player only.
29480                         UseTextureAlpha  bool
29481                         DmgTextureMod    Texture // suffix
29482                         Shaded           bool
29483                         ShowOnMinimap    bool
29484                         NametagBG        color.NRGBA
29485                 }))(obj)).StepHeight
29486                 write32(w, math.Float32bits(x))
29487         }
29488         {
29489                 x := (*(*(struct {
29490                         MaxHP            uint16 // Player only.
29491                         CollideWithNodes bool
29492                         Weight           float32 // deprecated
29493                         ColBox, SelBox   Box
29494                         Pointable        bool
29495                         Visual           string
29496                         VisualSize       [3]float32
29497                         Textures         []Texture
29498                         SpriteSheetSize  [2]int16 // in sprites.
29499                         SpritePos        [2]int16 // in sprite sheet.
29500                         Visible          bool
29501                         MakeFootstepSnds bool
29502                         RotateSpeed      float32 // in radians per second.
29503                         Mesh             string
29504                         Colors           []color.NRGBA
29505                         CollideWithAOs   bool
29506                         StepHeight       float32
29507                         FaceRotateDir    bool
29508                         FaceRotateDirOff float32 // in degrees.
29509                         BackfaceCull     bool
29510                         Nametag          string
29511                         NametagColor     color.NRGBA
29512                         FaceRotateSpeed  float32 // in degrees per second.
29513                         Infotext         string
29514                         Itemstring       string
29515                         Glow             int8
29516                         MaxBreath        uint16  // Player only.
29517                         EyeHeight        float32 // Player only.
29518                         ZoomFOV          float32 // in degrees. Player only.
29519                         UseTextureAlpha  bool
29520                         DmgTextureMod    Texture // suffix
29521                         Shaded           bool
29522                         ShowOnMinimap    bool
29523                         NametagBG        color.NRGBA
29524                 }))(obj)).FaceRotateDir
29525                 if x {
29526                         write8(w, 1)
29527                 } else {
29528                         write8(w, 0)
29529                 }
29530         }
29531         {
29532                 x := (*(*(struct {
29533                         MaxHP            uint16 // Player only.
29534                         CollideWithNodes bool
29535                         Weight           float32 // deprecated
29536                         ColBox, SelBox   Box
29537                         Pointable        bool
29538                         Visual           string
29539                         VisualSize       [3]float32
29540                         Textures         []Texture
29541                         SpriteSheetSize  [2]int16 // in sprites.
29542                         SpritePos        [2]int16 // in sprite sheet.
29543                         Visible          bool
29544                         MakeFootstepSnds bool
29545                         RotateSpeed      float32 // in radians per second.
29546                         Mesh             string
29547                         Colors           []color.NRGBA
29548                         CollideWithAOs   bool
29549                         StepHeight       float32
29550                         FaceRotateDir    bool
29551                         FaceRotateDirOff float32 // in degrees.
29552                         BackfaceCull     bool
29553                         Nametag          string
29554                         NametagColor     color.NRGBA
29555                         FaceRotateSpeed  float32 // in degrees per second.
29556                         Infotext         string
29557                         Itemstring       string
29558                         Glow             int8
29559                         MaxBreath        uint16  // Player only.
29560                         EyeHeight        float32 // Player only.
29561                         ZoomFOV          float32 // in degrees. Player only.
29562                         UseTextureAlpha  bool
29563                         DmgTextureMod    Texture // suffix
29564                         Shaded           bool
29565                         ShowOnMinimap    bool
29566                         NametagBG        color.NRGBA
29567                 }))(obj)).FaceRotateDirOff
29568                 write32(w, math.Float32bits(x))
29569         }
29570         {
29571                 x := (*(*(struct {
29572                         MaxHP            uint16 // Player only.
29573                         CollideWithNodes bool
29574                         Weight           float32 // deprecated
29575                         ColBox, SelBox   Box
29576                         Pointable        bool
29577                         Visual           string
29578                         VisualSize       [3]float32
29579                         Textures         []Texture
29580                         SpriteSheetSize  [2]int16 // in sprites.
29581                         SpritePos        [2]int16 // in sprite sheet.
29582                         Visible          bool
29583                         MakeFootstepSnds bool
29584                         RotateSpeed      float32 // in radians per second.
29585                         Mesh             string
29586                         Colors           []color.NRGBA
29587                         CollideWithAOs   bool
29588                         StepHeight       float32
29589                         FaceRotateDir    bool
29590                         FaceRotateDirOff float32 // in degrees.
29591                         BackfaceCull     bool
29592                         Nametag          string
29593                         NametagColor     color.NRGBA
29594                         FaceRotateSpeed  float32 // in degrees per second.
29595                         Infotext         string
29596                         Itemstring       string
29597                         Glow             int8
29598                         MaxBreath        uint16  // Player only.
29599                         EyeHeight        float32 // Player only.
29600                         ZoomFOV          float32 // in degrees. Player only.
29601                         UseTextureAlpha  bool
29602                         DmgTextureMod    Texture // suffix
29603                         Shaded           bool
29604                         ShowOnMinimap    bool
29605                         NametagBG        color.NRGBA
29606                 }))(obj)).BackfaceCull
29607                 if x {
29608                         write8(w, 1)
29609                 } else {
29610                         write8(w, 0)
29611                 }
29612         }
29613         if len(([]byte((*(*(struct {
29614                 MaxHP            uint16 // Player only.
29615                 CollideWithNodes bool
29616                 Weight           float32 // deprecated
29617                 ColBox, SelBox   Box
29618                 Pointable        bool
29619                 Visual           string
29620                 VisualSize       [3]float32
29621                 Textures         []Texture
29622                 SpriteSheetSize  [2]int16 // in sprites.
29623                 SpritePos        [2]int16 // in sprite sheet.
29624                 Visible          bool
29625                 MakeFootstepSnds bool
29626                 RotateSpeed      float32 // in radians per second.
29627                 Mesh             string
29628                 Colors           []color.NRGBA
29629                 CollideWithAOs   bool
29630                 StepHeight       float32
29631                 FaceRotateDir    bool
29632                 FaceRotateDirOff float32 // in degrees.
29633                 BackfaceCull     bool
29634                 Nametag          string
29635                 NametagColor     color.NRGBA
29636                 FaceRotateSpeed  float32 // in degrees per second.
29637                 Infotext         string
29638                 Itemstring       string
29639                 Glow             int8
29640                 MaxBreath        uint16  // Player only.
29641                 EyeHeight        float32 // Player only.
29642                 ZoomFOV          float32 // in degrees. Player only.
29643                 UseTextureAlpha  bool
29644                 DmgTextureMod    Texture // suffix
29645                 Shaded           bool
29646                 ShowOnMinimap    bool
29647                 NametagBG        color.NRGBA
29648         }))(obj)).Nametag))) > math.MaxUint16 {
29649                 chk(ErrTooLong)
29650         }
29651         {
29652                 x := uint16(len(([]byte((*(*(struct {
29653                         MaxHP            uint16 // Player only.
29654                         CollideWithNodes bool
29655                         Weight           float32 // deprecated
29656                         ColBox, SelBox   Box
29657                         Pointable        bool
29658                         Visual           string
29659                         VisualSize       [3]float32
29660                         Textures         []Texture
29661                         SpriteSheetSize  [2]int16 // in sprites.
29662                         SpritePos        [2]int16 // in sprite sheet.
29663                         Visible          bool
29664                         MakeFootstepSnds bool
29665                         RotateSpeed      float32 // in radians per second.
29666                         Mesh             string
29667                         Colors           []color.NRGBA
29668                         CollideWithAOs   bool
29669                         StepHeight       float32
29670                         FaceRotateDir    bool
29671                         FaceRotateDirOff float32 // in degrees.
29672                         BackfaceCull     bool
29673                         Nametag          string
29674                         NametagColor     color.NRGBA
29675                         FaceRotateSpeed  float32 // in degrees per second.
29676                         Infotext         string
29677                         Itemstring       string
29678                         Glow             int8
29679                         MaxBreath        uint16  // Player only.
29680                         EyeHeight        float32 // Player only.
29681                         ZoomFOV          float32 // in degrees. Player only.
29682                         UseTextureAlpha  bool
29683                         DmgTextureMod    Texture // suffix
29684                         Shaded           bool
29685                         ShowOnMinimap    bool
29686                         NametagBG        color.NRGBA
29687                 }))(obj)).Nametag))))
29688                 write16(w, uint16(x))
29689         }
29690         {
29691                 _, err := w.Write(([]byte((*(*(struct {
29692                         MaxHP            uint16 // Player only.
29693                         CollideWithNodes bool
29694                         Weight           float32 // deprecated
29695                         ColBox, SelBox   Box
29696                         Pointable        bool
29697                         Visual           string
29698                         VisualSize       [3]float32
29699                         Textures         []Texture
29700                         SpriteSheetSize  [2]int16 // in sprites.
29701                         SpritePos        [2]int16 // in sprite sheet.
29702                         Visible          bool
29703                         MakeFootstepSnds bool
29704                         RotateSpeed      float32 // in radians per second.
29705                         Mesh             string
29706                         Colors           []color.NRGBA
29707                         CollideWithAOs   bool
29708                         StepHeight       float32
29709                         FaceRotateDir    bool
29710                         FaceRotateDirOff float32 // in degrees.
29711                         BackfaceCull     bool
29712                         Nametag          string
29713                         NametagColor     color.NRGBA
29714                         FaceRotateSpeed  float32 // in degrees per second.
29715                         Infotext         string
29716                         Itemstring       string
29717                         Glow             int8
29718                         MaxBreath        uint16  // Player only.
29719                         EyeHeight        float32 // Player only.
29720                         ZoomFOV          float32 // in degrees. Player only.
29721                         UseTextureAlpha  bool
29722                         DmgTextureMod    Texture // suffix
29723                         Shaded           bool
29724                         ShowOnMinimap    bool
29725                         NametagBG        color.NRGBA
29726                 }))(obj)).Nametag))[:])
29727                 chk(err)
29728         }
29729         {
29730                 x := (*(*(struct {
29731                         MaxHP            uint16 // Player only.
29732                         CollideWithNodes bool
29733                         Weight           float32 // deprecated
29734                         ColBox, SelBox   Box
29735                         Pointable        bool
29736                         Visual           string
29737                         VisualSize       [3]float32
29738                         Textures         []Texture
29739                         SpriteSheetSize  [2]int16 // in sprites.
29740                         SpritePos        [2]int16 // in sprite sheet.
29741                         Visible          bool
29742                         MakeFootstepSnds bool
29743                         RotateSpeed      float32 // in radians per second.
29744                         Mesh             string
29745                         Colors           []color.NRGBA
29746                         CollideWithAOs   bool
29747                         StepHeight       float32
29748                         FaceRotateDir    bool
29749                         FaceRotateDirOff float32 // in degrees.
29750                         BackfaceCull     bool
29751                         Nametag          string
29752                         NametagColor     color.NRGBA
29753                         FaceRotateSpeed  float32 // in degrees per second.
29754                         Infotext         string
29755                         Itemstring       string
29756                         Glow             int8
29757                         MaxBreath        uint16  // Player only.
29758                         EyeHeight        float32 // Player only.
29759                         ZoomFOV          float32 // in degrees. Player only.
29760                         UseTextureAlpha  bool
29761                         DmgTextureMod    Texture // suffix
29762                         Shaded           bool
29763                         ShowOnMinimap    bool
29764                         NametagBG        color.NRGBA
29765                 }))(obj)).NametagColor
29766                 w.Write([]byte{x.A, x.R, x.G, x.B})
29767         }
29768         {
29769                 x := (*(*(struct {
29770                         MaxHP            uint16 // Player only.
29771                         CollideWithNodes bool
29772                         Weight           float32 // deprecated
29773                         ColBox, SelBox   Box
29774                         Pointable        bool
29775                         Visual           string
29776                         VisualSize       [3]float32
29777                         Textures         []Texture
29778                         SpriteSheetSize  [2]int16 // in sprites.
29779                         SpritePos        [2]int16 // in sprite sheet.
29780                         Visible          bool
29781                         MakeFootstepSnds bool
29782                         RotateSpeed      float32 // in radians per second.
29783                         Mesh             string
29784                         Colors           []color.NRGBA
29785                         CollideWithAOs   bool
29786                         StepHeight       float32
29787                         FaceRotateDir    bool
29788                         FaceRotateDirOff float32 // in degrees.
29789                         BackfaceCull     bool
29790                         Nametag          string
29791                         NametagColor     color.NRGBA
29792                         FaceRotateSpeed  float32 // in degrees per second.
29793                         Infotext         string
29794                         Itemstring       string
29795                         Glow             int8
29796                         MaxBreath        uint16  // Player only.
29797                         EyeHeight        float32 // Player only.
29798                         ZoomFOV          float32 // in degrees. Player only.
29799                         UseTextureAlpha  bool
29800                         DmgTextureMod    Texture // suffix
29801                         Shaded           bool
29802                         ShowOnMinimap    bool
29803                         NametagBG        color.NRGBA
29804                 }))(obj)).FaceRotateSpeed
29805                 write32(w, math.Float32bits(x))
29806         }
29807         if len(([]byte((*(*(struct {
29808                 MaxHP            uint16 // Player only.
29809                 CollideWithNodes bool
29810                 Weight           float32 // deprecated
29811                 ColBox, SelBox   Box
29812                 Pointable        bool
29813                 Visual           string
29814                 VisualSize       [3]float32
29815                 Textures         []Texture
29816                 SpriteSheetSize  [2]int16 // in sprites.
29817                 SpritePos        [2]int16 // in sprite sheet.
29818                 Visible          bool
29819                 MakeFootstepSnds bool
29820                 RotateSpeed      float32 // in radians per second.
29821                 Mesh             string
29822                 Colors           []color.NRGBA
29823                 CollideWithAOs   bool
29824                 StepHeight       float32
29825                 FaceRotateDir    bool
29826                 FaceRotateDirOff float32 // in degrees.
29827                 BackfaceCull     bool
29828                 Nametag          string
29829                 NametagColor     color.NRGBA
29830                 FaceRotateSpeed  float32 // in degrees per second.
29831                 Infotext         string
29832                 Itemstring       string
29833                 Glow             int8
29834                 MaxBreath        uint16  // Player only.
29835                 EyeHeight        float32 // Player only.
29836                 ZoomFOV          float32 // in degrees. Player only.
29837                 UseTextureAlpha  bool
29838                 DmgTextureMod    Texture // suffix
29839                 Shaded           bool
29840                 ShowOnMinimap    bool
29841                 NametagBG        color.NRGBA
29842         }))(obj)).Infotext))) > math.MaxUint16 {
29843                 chk(ErrTooLong)
29844         }
29845         {
29846                 x := uint16(len(([]byte((*(*(struct {
29847                         MaxHP            uint16 // Player only.
29848                         CollideWithNodes bool
29849                         Weight           float32 // deprecated
29850                         ColBox, SelBox   Box
29851                         Pointable        bool
29852                         Visual           string
29853                         VisualSize       [3]float32
29854                         Textures         []Texture
29855                         SpriteSheetSize  [2]int16 // in sprites.
29856                         SpritePos        [2]int16 // in sprite sheet.
29857                         Visible          bool
29858                         MakeFootstepSnds bool
29859                         RotateSpeed      float32 // in radians per second.
29860                         Mesh             string
29861                         Colors           []color.NRGBA
29862                         CollideWithAOs   bool
29863                         StepHeight       float32
29864                         FaceRotateDir    bool
29865                         FaceRotateDirOff float32 // in degrees.
29866                         BackfaceCull     bool
29867                         Nametag          string
29868                         NametagColor     color.NRGBA
29869                         FaceRotateSpeed  float32 // in degrees per second.
29870                         Infotext         string
29871                         Itemstring       string
29872                         Glow             int8
29873                         MaxBreath        uint16  // Player only.
29874                         EyeHeight        float32 // Player only.
29875                         ZoomFOV          float32 // in degrees. Player only.
29876                         UseTextureAlpha  bool
29877                         DmgTextureMod    Texture // suffix
29878                         Shaded           bool
29879                         ShowOnMinimap    bool
29880                         NametagBG        color.NRGBA
29881                 }))(obj)).Infotext))))
29882                 write16(w, uint16(x))
29883         }
29884         {
29885                 _, err := w.Write(([]byte((*(*(struct {
29886                         MaxHP            uint16 // Player only.
29887                         CollideWithNodes bool
29888                         Weight           float32 // deprecated
29889                         ColBox, SelBox   Box
29890                         Pointable        bool
29891                         Visual           string
29892                         VisualSize       [3]float32
29893                         Textures         []Texture
29894                         SpriteSheetSize  [2]int16 // in sprites.
29895                         SpritePos        [2]int16 // in sprite sheet.
29896                         Visible          bool
29897                         MakeFootstepSnds bool
29898                         RotateSpeed      float32 // in radians per second.
29899                         Mesh             string
29900                         Colors           []color.NRGBA
29901                         CollideWithAOs   bool
29902                         StepHeight       float32
29903                         FaceRotateDir    bool
29904                         FaceRotateDirOff float32 // in degrees.
29905                         BackfaceCull     bool
29906                         Nametag          string
29907                         NametagColor     color.NRGBA
29908                         FaceRotateSpeed  float32 // in degrees per second.
29909                         Infotext         string
29910                         Itemstring       string
29911                         Glow             int8
29912                         MaxBreath        uint16  // Player only.
29913                         EyeHeight        float32 // Player only.
29914                         ZoomFOV          float32 // in degrees. Player only.
29915                         UseTextureAlpha  bool
29916                         DmgTextureMod    Texture // suffix
29917                         Shaded           bool
29918                         ShowOnMinimap    bool
29919                         NametagBG        color.NRGBA
29920                 }))(obj)).Infotext))[:])
29921                 chk(err)
29922         }
29923         if len(([]byte((*(*(struct {
29924                 MaxHP            uint16 // Player only.
29925                 CollideWithNodes bool
29926                 Weight           float32 // deprecated
29927                 ColBox, SelBox   Box
29928                 Pointable        bool
29929                 Visual           string
29930                 VisualSize       [3]float32
29931                 Textures         []Texture
29932                 SpriteSheetSize  [2]int16 // in sprites.
29933                 SpritePos        [2]int16 // in sprite sheet.
29934                 Visible          bool
29935                 MakeFootstepSnds bool
29936                 RotateSpeed      float32 // in radians per second.
29937                 Mesh             string
29938                 Colors           []color.NRGBA
29939                 CollideWithAOs   bool
29940                 StepHeight       float32
29941                 FaceRotateDir    bool
29942                 FaceRotateDirOff float32 // in degrees.
29943                 BackfaceCull     bool
29944                 Nametag          string
29945                 NametagColor     color.NRGBA
29946                 FaceRotateSpeed  float32 // in degrees per second.
29947                 Infotext         string
29948                 Itemstring       string
29949                 Glow             int8
29950                 MaxBreath        uint16  // Player only.
29951                 EyeHeight        float32 // Player only.
29952                 ZoomFOV          float32 // in degrees. Player only.
29953                 UseTextureAlpha  bool
29954                 DmgTextureMod    Texture // suffix
29955                 Shaded           bool
29956                 ShowOnMinimap    bool
29957                 NametagBG        color.NRGBA
29958         }))(obj)).Itemstring))) > math.MaxUint16 {
29959                 chk(ErrTooLong)
29960         }
29961         {
29962                 x := uint16(len(([]byte((*(*(struct {
29963                         MaxHP            uint16 // Player only.
29964                         CollideWithNodes bool
29965                         Weight           float32 // deprecated
29966                         ColBox, SelBox   Box
29967                         Pointable        bool
29968                         Visual           string
29969                         VisualSize       [3]float32
29970                         Textures         []Texture
29971                         SpriteSheetSize  [2]int16 // in sprites.
29972                         SpritePos        [2]int16 // in sprite sheet.
29973                         Visible          bool
29974                         MakeFootstepSnds bool
29975                         RotateSpeed      float32 // in radians per second.
29976                         Mesh             string
29977                         Colors           []color.NRGBA
29978                         CollideWithAOs   bool
29979                         StepHeight       float32
29980                         FaceRotateDir    bool
29981                         FaceRotateDirOff float32 // in degrees.
29982                         BackfaceCull     bool
29983                         Nametag          string
29984                         NametagColor     color.NRGBA
29985                         FaceRotateSpeed  float32 // in degrees per second.
29986                         Infotext         string
29987                         Itemstring       string
29988                         Glow             int8
29989                         MaxBreath        uint16  // Player only.
29990                         EyeHeight        float32 // Player only.
29991                         ZoomFOV          float32 // in degrees. Player only.
29992                         UseTextureAlpha  bool
29993                         DmgTextureMod    Texture // suffix
29994                         Shaded           bool
29995                         ShowOnMinimap    bool
29996                         NametagBG        color.NRGBA
29997                 }))(obj)).Itemstring))))
29998                 write16(w, uint16(x))
29999         }
30000         {
30001                 _, err := w.Write(([]byte((*(*(struct {
30002                         MaxHP            uint16 // Player only.
30003                         CollideWithNodes bool
30004                         Weight           float32 // deprecated
30005                         ColBox, SelBox   Box
30006                         Pointable        bool
30007                         Visual           string
30008                         VisualSize       [3]float32
30009                         Textures         []Texture
30010                         SpriteSheetSize  [2]int16 // in sprites.
30011                         SpritePos        [2]int16 // in sprite sheet.
30012                         Visible          bool
30013                         MakeFootstepSnds bool
30014                         RotateSpeed      float32 // in radians per second.
30015                         Mesh             string
30016                         Colors           []color.NRGBA
30017                         CollideWithAOs   bool
30018                         StepHeight       float32
30019                         FaceRotateDir    bool
30020                         FaceRotateDirOff float32 // in degrees.
30021                         BackfaceCull     bool
30022                         Nametag          string
30023                         NametagColor     color.NRGBA
30024                         FaceRotateSpeed  float32 // in degrees per second.
30025                         Infotext         string
30026                         Itemstring       string
30027                         Glow             int8
30028                         MaxBreath        uint16  // Player only.
30029                         EyeHeight        float32 // Player only.
30030                         ZoomFOV          float32 // in degrees. Player only.
30031                         UseTextureAlpha  bool
30032                         DmgTextureMod    Texture // suffix
30033                         Shaded           bool
30034                         ShowOnMinimap    bool
30035                         NametagBG        color.NRGBA
30036                 }))(obj)).Itemstring))[:])
30037                 chk(err)
30038         }
30039         {
30040                 x := (*(*(struct {
30041                         MaxHP            uint16 // Player only.
30042                         CollideWithNodes bool
30043                         Weight           float32 // deprecated
30044                         ColBox, SelBox   Box
30045                         Pointable        bool
30046                         Visual           string
30047                         VisualSize       [3]float32
30048                         Textures         []Texture
30049                         SpriteSheetSize  [2]int16 // in sprites.
30050                         SpritePos        [2]int16 // in sprite sheet.
30051                         Visible          bool
30052                         MakeFootstepSnds bool
30053                         RotateSpeed      float32 // in radians per second.
30054                         Mesh             string
30055                         Colors           []color.NRGBA
30056                         CollideWithAOs   bool
30057                         StepHeight       float32
30058                         FaceRotateDir    bool
30059                         FaceRotateDirOff float32 // in degrees.
30060                         BackfaceCull     bool
30061                         Nametag          string
30062                         NametagColor     color.NRGBA
30063                         FaceRotateSpeed  float32 // in degrees per second.
30064                         Infotext         string
30065                         Itemstring       string
30066                         Glow             int8
30067                         MaxBreath        uint16  // Player only.
30068                         EyeHeight        float32 // Player only.
30069                         ZoomFOV          float32 // in degrees. Player only.
30070                         UseTextureAlpha  bool
30071                         DmgTextureMod    Texture // suffix
30072                         Shaded           bool
30073                         ShowOnMinimap    bool
30074                         NametagBG        color.NRGBA
30075                 }))(obj)).Glow
30076                 write8(w, uint8(x))
30077         }
30078         {
30079                 x := (*(*(struct {
30080                         MaxHP            uint16 // Player only.
30081                         CollideWithNodes bool
30082                         Weight           float32 // deprecated
30083                         ColBox, SelBox   Box
30084                         Pointable        bool
30085                         Visual           string
30086                         VisualSize       [3]float32
30087                         Textures         []Texture
30088                         SpriteSheetSize  [2]int16 // in sprites.
30089                         SpritePos        [2]int16 // in sprite sheet.
30090                         Visible          bool
30091                         MakeFootstepSnds bool
30092                         RotateSpeed      float32 // in radians per second.
30093                         Mesh             string
30094                         Colors           []color.NRGBA
30095                         CollideWithAOs   bool
30096                         StepHeight       float32
30097                         FaceRotateDir    bool
30098                         FaceRotateDirOff float32 // in degrees.
30099                         BackfaceCull     bool
30100                         Nametag          string
30101                         NametagColor     color.NRGBA
30102                         FaceRotateSpeed  float32 // in degrees per second.
30103                         Infotext         string
30104                         Itemstring       string
30105                         Glow             int8
30106                         MaxBreath        uint16  // Player only.
30107                         EyeHeight        float32 // Player only.
30108                         ZoomFOV          float32 // in degrees. Player only.
30109                         UseTextureAlpha  bool
30110                         DmgTextureMod    Texture // suffix
30111                         Shaded           bool
30112                         ShowOnMinimap    bool
30113                         NametagBG        color.NRGBA
30114                 }))(obj)).MaxBreath
30115                 write16(w, uint16(x))
30116         }
30117         {
30118                 x := (*(*(struct {
30119                         MaxHP            uint16 // Player only.
30120                         CollideWithNodes bool
30121                         Weight           float32 // deprecated
30122                         ColBox, SelBox   Box
30123                         Pointable        bool
30124                         Visual           string
30125                         VisualSize       [3]float32
30126                         Textures         []Texture
30127                         SpriteSheetSize  [2]int16 // in sprites.
30128                         SpritePos        [2]int16 // in sprite sheet.
30129                         Visible          bool
30130                         MakeFootstepSnds bool
30131                         RotateSpeed      float32 // in radians per second.
30132                         Mesh             string
30133                         Colors           []color.NRGBA
30134                         CollideWithAOs   bool
30135                         StepHeight       float32
30136                         FaceRotateDir    bool
30137                         FaceRotateDirOff float32 // in degrees.
30138                         BackfaceCull     bool
30139                         Nametag          string
30140                         NametagColor     color.NRGBA
30141                         FaceRotateSpeed  float32 // in degrees per second.
30142                         Infotext         string
30143                         Itemstring       string
30144                         Glow             int8
30145                         MaxBreath        uint16  // Player only.
30146                         EyeHeight        float32 // Player only.
30147                         ZoomFOV          float32 // in degrees. Player only.
30148                         UseTextureAlpha  bool
30149                         DmgTextureMod    Texture // suffix
30150                         Shaded           bool
30151                         ShowOnMinimap    bool
30152                         NametagBG        color.NRGBA
30153                 }))(obj)).EyeHeight
30154                 write32(w, math.Float32bits(x))
30155         }
30156         {
30157                 x := (*(*(struct {
30158                         MaxHP            uint16 // Player only.
30159                         CollideWithNodes bool
30160                         Weight           float32 // deprecated
30161                         ColBox, SelBox   Box
30162                         Pointable        bool
30163                         Visual           string
30164                         VisualSize       [3]float32
30165                         Textures         []Texture
30166                         SpriteSheetSize  [2]int16 // in sprites.
30167                         SpritePos        [2]int16 // in sprite sheet.
30168                         Visible          bool
30169                         MakeFootstepSnds bool
30170                         RotateSpeed      float32 // in radians per second.
30171                         Mesh             string
30172                         Colors           []color.NRGBA
30173                         CollideWithAOs   bool
30174                         StepHeight       float32
30175                         FaceRotateDir    bool
30176                         FaceRotateDirOff float32 // in degrees.
30177                         BackfaceCull     bool
30178                         Nametag          string
30179                         NametagColor     color.NRGBA
30180                         FaceRotateSpeed  float32 // in degrees per second.
30181                         Infotext         string
30182                         Itemstring       string
30183                         Glow             int8
30184                         MaxBreath        uint16  // Player only.
30185                         EyeHeight        float32 // Player only.
30186                         ZoomFOV          float32 // in degrees. Player only.
30187                         UseTextureAlpha  bool
30188                         DmgTextureMod    Texture // suffix
30189                         Shaded           bool
30190                         ShowOnMinimap    bool
30191                         NametagBG        color.NRGBA
30192                 }))(obj)).ZoomFOV
30193                 write32(w, math.Float32bits(x))
30194         }
30195         {
30196                 x := (*(*(struct {
30197                         MaxHP            uint16 // Player only.
30198                         CollideWithNodes bool
30199                         Weight           float32 // deprecated
30200                         ColBox, SelBox   Box
30201                         Pointable        bool
30202                         Visual           string
30203                         VisualSize       [3]float32
30204                         Textures         []Texture
30205                         SpriteSheetSize  [2]int16 // in sprites.
30206                         SpritePos        [2]int16 // in sprite sheet.
30207                         Visible          bool
30208                         MakeFootstepSnds bool
30209                         RotateSpeed      float32 // in radians per second.
30210                         Mesh             string
30211                         Colors           []color.NRGBA
30212                         CollideWithAOs   bool
30213                         StepHeight       float32
30214                         FaceRotateDir    bool
30215                         FaceRotateDirOff float32 // in degrees.
30216                         BackfaceCull     bool
30217                         Nametag          string
30218                         NametagColor     color.NRGBA
30219                         FaceRotateSpeed  float32 // in degrees per second.
30220                         Infotext         string
30221                         Itemstring       string
30222                         Glow             int8
30223                         MaxBreath        uint16  // Player only.
30224                         EyeHeight        float32 // Player only.
30225                         ZoomFOV          float32 // in degrees. Player only.
30226                         UseTextureAlpha  bool
30227                         DmgTextureMod    Texture // suffix
30228                         Shaded           bool
30229                         ShowOnMinimap    bool
30230                         NametagBG        color.NRGBA
30231                 }))(obj)).UseTextureAlpha
30232                 if x {
30233                         write8(w, 1)
30234                 } else {
30235                         write8(w, 0)
30236                 }
30237         }
30238         if err := pcall(func() {
30239                 ((*(*(struct {
30240                         MaxHP            uint16 // Player only.
30241                         CollideWithNodes bool
30242                         Weight           float32 // deprecated
30243                         ColBox, SelBox   Box
30244                         Pointable        bool
30245                         Visual           string
30246                         VisualSize       [3]float32
30247                         Textures         []Texture
30248                         SpriteSheetSize  [2]int16 // in sprites.
30249                         SpritePos        [2]int16 // in sprite sheet.
30250                         Visible          bool
30251                         MakeFootstepSnds bool
30252                         RotateSpeed      float32 // in radians per second.
30253                         Mesh             string
30254                         Colors           []color.NRGBA
30255                         CollideWithAOs   bool
30256                         StepHeight       float32
30257                         FaceRotateDir    bool
30258                         FaceRotateDirOff float32 // in degrees.
30259                         BackfaceCull     bool
30260                         Nametag          string
30261                         NametagColor     color.NRGBA
30262                         FaceRotateSpeed  float32 // in degrees per second.
30263                         Infotext         string
30264                         Itemstring       string
30265                         Glow             int8
30266                         MaxBreath        uint16  // Player only.
30267                         EyeHeight        float32 // Player only.
30268                         ZoomFOV          float32 // in degrees. Player only.
30269                         UseTextureAlpha  bool
30270                         DmgTextureMod    Texture // suffix
30271                         Shaded           bool
30272                         ShowOnMinimap    bool
30273                         NametagBG        color.NRGBA
30274                 }))(obj)).DmgTextureMod).serialize(w)
30275         }); err != nil {
30276                 if err == io.EOF {
30277                         chk(io.EOF)
30278                 }
30279                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
30280         }
30281         {
30282                 x := (*(*(struct {
30283                         MaxHP            uint16 // Player only.
30284                         CollideWithNodes bool
30285                         Weight           float32 // deprecated
30286                         ColBox, SelBox   Box
30287                         Pointable        bool
30288                         Visual           string
30289                         VisualSize       [3]float32
30290                         Textures         []Texture
30291                         SpriteSheetSize  [2]int16 // in sprites.
30292                         SpritePos        [2]int16 // in sprite sheet.
30293                         Visible          bool
30294                         MakeFootstepSnds bool
30295                         RotateSpeed      float32 // in radians per second.
30296                         Mesh             string
30297                         Colors           []color.NRGBA
30298                         CollideWithAOs   bool
30299                         StepHeight       float32
30300                         FaceRotateDir    bool
30301                         FaceRotateDirOff float32 // in degrees.
30302                         BackfaceCull     bool
30303                         Nametag          string
30304                         NametagColor     color.NRGBA
30305                         FaceRotateSpeed  float32 // in degrees per second.
30306                         Infotext         string
30307                         Itemstring       string
30308                         Glow             int8
30309                         MaxBreath        uint16  // Player only.
30310                         EyeHeight        float32 // Player only.
30311                         ZoomFOV          float32 // in degrees. Player only.
30312                         UseTextureAlpha  bool
30313                         DmgTextureMod    Texture // suffix
30314                         Shaded           bool
30315                         ShowOnMinimap    bool
30316                         NametagBG        color.NRGBA
30317                 }))(obj)).Shaded
30318                 if x {
30319                         write8(w, 1)
30320                 } else {
30321                         write8(w, 0)
30322                 }
30323         }
30324         {
30325                 x := (*(*(struct {
30326                         MaxHP            uint16 // Player only.
30327                         CollideWithNodes bool
30328                         Weight           float32 // deprecated
30329                         ColBox, SelBox   Box
30330                         Pointable        bool
30331                         Visual           string
30332                         VisualSize       [3]float32
30333                         Textures         []Texture
30334                         SpriteSheetSize  [2]int16 // in sprites.
30335                         SpritePos        [2]int16 // in sprite sheet.
30336                         Visible          bool
30337                         MakeFootstepSnds bool
30338                         RotateSpeed      float32 // in radians per second.
30339                         Mesh             string
30340                         Colors           []color.NRGBA
30341                         CollideWithAOs   bool
30342                         StepHeight       float32
30343                         FaceRotateDir    bool
30344                         FaceRotateDirOff float32 // in degrees.
30345                         BackfaceCull     bool
30346                         Nametag          string
30347                         NametagColor     color.NRGBA
30348                         FaceRotateSpeed  float32 // in degrees per second.
30349                         Infotext         string
30350                         Itemstring       string
30351                         Glow             int8
30352                         MaxBreath        uint16  // Player only.
30353                         EyeHeight        float32 // Player only.
30354                         ZoomFOV          float32 // in degrees. Player only.
30355                         UseTextureAlpha  bool
30356                         DmgTextureMod    Texture // suffix
30357                         Shaded           bool
30358                         ShowOnMinimap    bool
30359                         NametagBG        color.NRGBA
30360                 }))(obj)).ShowOnMinimap
30361                 if x {
30362                         write8(w, 1)
30363                 } else {
30364                         write8(w, 0)
30365                 }
30366         }
30367         {
30368                 x := (*(*(struct {
30369                         MaxHP            uint16 // Player only.
30370                         CollideWithNodes bool
30371                         Weight           float32 // deprecated
30372                         ColBox, SelBox   Box
30373                         Pointable        bool
30374                         Visual           string
30375                         VisualSize       [3]float32
30376                         Textures         []Texture
30377                         SpriteSheetSize  [2]int16 // in sprites.
30378                         SpritePos        [2]int16 // in sprite sheet.
30379                         Visible          bool
30380                         MakeFootstepSnds bool
30381                         RotateSpeed      float32 // in radians per second.
30382                         Mesh             string
30383                         Colors           []color.NRGBA
30384                         CollideWithAOs   bool
30385                         StepHeight       float32
30386                         FaceRotateDir    bool
30387                         FaceRotateDirOff float32 // in degrees.
30388                         BackfaceCull     bool
30389                         Nametag          string
30390                         NametagColor     color.NRGBA
30391                         FaceRotateSpeed  float32 // in degrees per second.
30392                         Infotext         string
30393                         Itemstring       string
30394                         Glow             int8
30395                         MaxBreath        uint16  // Player only.
30396                         EyeHeight        float32 // Player only.
30397                         ZoomFOV          float32 // in degrees. Player only.
30398                         UseTextureAlpha  bool
30399                         DmgTextureMod    Texture // suffix
30400                         Shaded           bool
30401                         ShowOnMinimap    bool
30402                         NametagBG        color.NRGBA
30403                 }))(obj)).NametagBG
30404                 w.Write([]byte{x.A, x.R, x.G, x.B})
30405         }
30406 }
30407
30408 func (obj *AOProps) deserialize(r io.Reader) {
30409         {
30410                 var local336 uint8
30411                 local337 := uint8(4)
30412                 {
30413                         p := &local336
30414                         *p = read8(r)
30415                 }
30416                 if local336 != local337 {
30417                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local336))
30418                 }
30419         }
30420         {
30421                 p := &(*(*(struct {
30422                         MaxHP            uint16 // Player only.
30423                         CollideWithNodes bool
30424                         Weight           float32 // deprecated
30425                         ColBox, SelBox   Box
30426                         Pointable        bool
30427                         Visual           string
30428                         VisualSize       [3]float32
30429                         Textures         []Texture
30430                         SpriteSheetSize  [2]int16 // in sprites.
30431                         SpritePos        [2]int16 // in sprite sheet.
30432                         Visible          bool
30433                         MakeFootstepSnds bool
30434                         RotateSpeed      float32 // in radians per second.
30435                         Mesh             string
30436                         Colors           []color.NRGBA
30437                         CollideWithAOs   bool
30438                         StepHeight       float32
30439                         FaceRotateDir    bool
30440                         FaceRotateDirOff float32 // in degrees.
30441                         BackfaceCull     bool
30442                         Nametag          string
30443                         NametagColor     color.NRGBA
30444                         FaceRotateSpeed  float32 // in degrees per second.
30445                         Infotext         string
30446                         Itemstring       string
30447                         Glow             int8
30448                         MaxBreath        uint16  // Player only.
30449                         EyeHeight        float32 // Player only.
30450                         ZoomFOV          float32 // in degrees. Player only.
30451                         UseTextureAlpha  bool
30452                         DmgTextureMod    Texture // suffix
30453                         Shaded           bool
30454                         ShowOnMinimap    bool
30455                         NametagBG        color.NRGBA
30456                 }))(obj)).MaxHP
30457                 *p = read16(r)
30458         }
30459         {
30460                 p := &(*(*(struct {
30461                         MaxHP            uint16 // Player only.
30462                         CollideWithNodes bool
30463                         Weight           float32 // deprecated
30464                         ColBox, SelBox   Box
30465                         Pointable        bool
30466                         Visual           string
30467                         VisualSize       [3]float32
30468                         Textures         []Texture
30469                         SpriteSheetSize  [2]int16 // in sprites.
30470                         SpritePos        [2]int16 // in sprite sheet.
30471                         Visible          bool
30472                         MakeFootstepSnds bool
30473                         RotateSpeed      float32 // in radians per second.
30474                         Mesh             string
30475                         Colors           []color.NRGBA
30476                         CollideWithAOs   bool
30477                         StepHeight       float32
30478                         FaceRotateDir    bool
30479                         FaceRotateDirOff float32 // in degrees.
30480                         BackfaceCull     bool
30481                         Nametag          string
30482                         NametagColor     color.NRGBA
30483                         FaceRotateSpeed  float32 // in degrees per second.
30484                         Infotext         string
30485                         Itemstring       string
30486                         Glow             int8
30487                         MaxBreath        uint16  // Player only.
30488                         EyeHeight        float32 // Player only.
30489                         ZoomFOV          float32 // in degrees. Player only.
30490                         UseTextureAlpha  bool
30491                         DmgTextureMod    Texture // suffix
30492                         Shaded           bool
30493                         ShowOnMinimap    bool
30494                         NametagBG        color.NRGBA
30495                 }))(obj)).CollideWithNodes
30496                 switch n := read8(r); n {
30497                 case 0:
30498                         *p = false
30499                 case 1:
30500                         *p = true
30501                 default:
30502                         chk(fmt.Errorf("invalid bool: %d", n))
30503                 }
30504         }
30505         {
30506                 p := &(*(*(struct {
30507                         MaxHP            uint16 // Player only.
30508                         CollideWithNodes bool
30509                         Weight           float32 // deprecated
30510                         ColBox, SelBox   Box
30511                         Pointable        bool
30512                         Visual           string
30513                         VisualSize       [3]float32
30514                         Textures         []Texture
30515                         SpriteSheetSize  [2]int16 // in sprites.
30516                         SpritePos        [2]int16 // in sprite sheet.
30517                         Visible          bool
30518                         MakeFootstepSnds bool
30519                         RotateSpeed      float32 // in radians per second.
30520                         Mesh             string
30521                         Colors           []color.NRGBA
30522                         CollideWithAOs   bool
30523                         StepHeight       float32
30524                         FaceRotateDir    bool
30525                         FaceRotateDirOff float32 // in degrees.
30526                         BackfaceCull     bool
30527                         Nametag          string
30528                         NametagColor     color.NRGBA
30529                         FaceRotateSpeed  float32 // in degrees per second.
30530                         Infotext         string
30531                         Itemstring       string
30532                         Glow             int8
30533                         MaxBreath        uint16  // Player only.
30534                         EyeHeight        float32 // Player only.
30535                         ZoomFOV          float32 // in degrees. Player only.
30536                         UseTextureAlpha  bool
30537                         DmgTextureMod    Texture // suffix
30538                         Shaded           bool
30539                         ShowOnMinimap    bool
30540                         NametagBG        color.NRGBA
30541                 }))(obj)).Weight
30542                 *p = math.Float32frombits(read32(r))
30543         }
30544         if err := pcall(func() {
30545                 ((*(*(struct {
30546                         MaxHP            uint16 // Player only.
30547                         CollideWithNodes bool
30548                         Weight           float32 // deprecated
30549                         ColBox, SelBox   Box
30550                         Pointable        bool
30551                         Visual           string
30552                         VisualSize       [3]float32
30553                         Textures         []Texture
30554                         SpriteSheetSize  [2]int16 // in sprites.
30555                         SpritePos        [2]int16 // in sprite sheet.
30556                         Visible          bool
30557                         MakeFootstepSnds bool
30558                         RotateSpeed      float32 // in radians per second.
30559                         Mesh             string
30560                         Colors           []color.NRGBA
30561                         CollideWithAOs   bool
30562                         StepHeight       float32
30563                         FaceRotateDir    bool
30564                         FaceRotateDirOff float32 // in degrees.
30565                         BackfaceCull     bool
30566                         Nametag          string
30567                         NametagColor     color.NRGBA
30568                         FaceRotateSpeed  float32 // in degrees per second.
30569                         Infotext         string
30570                         Itemstring       string
30571                         Glow             int8
30572                         MaxBreath        uint16  // Player only.
30573                         EyeHeight        float32 // Player only.
30574                         ZoomFOV          float32 // in degrees. Player only.
30575                         UseTextureAlpha  bool
30576                         DmgTextureMod    Texture // suffix
30577                         Shaded           bool
30578                         ShowOnMinimap    bool
30579                         NametagBG        color.NRGBA
30580                 }))(obj)).ColBox).deserialize(r)
30581         }); err != nil {
30582                 if err == io.EOF {
30583                         chk(io.EOF)
30584                 }
30585                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
30586         }
30587         if err := pcall(func() {
30588                 ((*(*(struct {
30589                         MaxHP            uint16 // Player only.
30590                         CollideWithNodes bool
30591                         Weight           float32 // deprecated
30592                         ColBox, SelBox   Box
30593                         Pointable        bool
30594                         Visual           string
30595                         VisualSize       [3]float32
30596                         Textures         []Texture
30597                         SpriteSheetSize  [2]int16 // in sprites.
30598                         SpritePos        [2]int16 // in sprite sheet.
30599                         Visible          bool
30600                         MakeFootstepSnds bool
30601                         RotateSpeed      float32 // in radians per second.
30602                         Mesh             string
30603                         Colors           []color.NRGBA
30604                         CollideWithAOs   bool
30605                         StepHeight       float32
30606                         FaceRotateDir    bool
30607                         FaceRotateDirOff float32 // in degrees.
30608                         BackfaceCull     bool
30609                         Nametag          string
30610                         NametagColor     color.NRGBA
30611                         FaceRotateSpeed  float32 // in degrees per second.
30612                         Infotext         string
30613                         Itemstring       string
30614                         Glow             int8
30615                         MaxBreath        uint16  // Player only.
30616                         EyeHeight        float32 // Player only.
30617                         ZoomFOV          float32 // in degrees. Player only.
30618                         UseTextureAlpha  bool
30619                         DmgTextureMod    Texture // suffix
30620                         Shaded           bool
30621                         ShowOnMinimap    bool
30622                         NametagBG        color.NRGBA
30623                 }))(obj)).SelBox).deserialize(r)
30624         }); err != nil {
30625                 if err == io.EOF {
30626                         chk(io.EOF)
30627                 }
30628                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
30629         }
30630         {
30631                 p := &(*(*(struct {
30632                         MaxHP            uint16 // Player only.
30633                         CollideWithNodes bool
30634                         Weight           float32 // deprecated
30635                         ColBox, SelBox   Box
30636                         Pointable        bool
30637                         Visual           string
30638                         VisualSize       [3]float32
30639                         Textures         []Texture
30640                         SpriteSheetSize  [2]int16 // in sprites.
30641                         SpritePos        [2]int16 // in sprite sheet.
30642                         Visible          bool
30643                         MakeFootstepSnds bool
30644                         RotateSpeed      float32 // in radians per second.
30645                         Mesh             string
30646                         Colors           []color.NRGBA
30647                         CollideWithAOs   bool
30648                         StepHeight       float32
30649                         FaceRotateDir    bool
30650                         FaceRotateDirOff float32 // in degrees.
30651                         BackfaceCull     bool
30652                         Nametag          string
30653                         NametagColor     color.NRGBA
30654                         FaceRotateSpeed  float32 // in degrees per second.
30655                         Infotext         string
30656                         Itemstring       string
30657                         Glow             int8
30658                         MaxBreath        uint16  // Player only.
30659                         EyeHeight        float32 // Player only.
30660                         ZoomFOV          float32 // in degrees. Player only.
30661                         UseTextureAlpha  bool
30662                         DmgTextureMod    Texture // suffix
30663                         Shaded           bool
30664                         ShowOnMinimap    bool
30665                         NametagBG        color.NRGBA
30666                 }))(obj)).Pointable
30667                 switch n := read8(r); n {
30668                 case 0:
30669                         *p = false
30670                 case 1:
30671                         *p = true
30672                 default:
30673                         chk(fmt.Errorf("invalid bool: %d", n))
30674                 }
30675         }
30676         var local338 []uint8
30677         var local339 uint16
30678         {
30679                 p := &local339
30680                 *p = read16(r)
30681         }
30682         (local338) = make([]uint8, local339)
30683         {
30684                 _, err := io.ReadFull(r, (local338)[:])
30685                 chk(err)
30686         }
30687         ((*(*(struct {
30688                 MaxHP            uint16 // Player only.
30689                 CollideWithNodes bool
30690                 Weight           float32 // deprecated
30691                 ColBox, SelBox   Box
30692                 Pointable        bool
30693                 Visual           string
30694                 VisualSize       [3]float32
30695                 Textures         []Texture
30696                 SpriteSheetSize  [2]int16 // in sprites.
30697                 SpritePos        [2]int16 // in sprite sheet.
30698                 Visible          bool
30699                 MakeFootstepSnds bool
30700                 RotateSpeed      float32 // in radians per second.
30701                 Mesh             string
30702                 Colors           []color.NRGBA
30703                 CollideWithAOs   bool
30704                 StepHeight       float32
30705                 FaceRotateDir    bool
30706                 FaceRotateDirOff float32 // in degrees.
30707                 BackfaceCull     bool
30708                 Nametag          string
30709                 NametagColor     color.NRGBA
30710                 FaceRotateSpeed  float32 // in degrees per second.
30711                 Infotext         string
30712                 Itemstring       string
30713                 Glow             int8
30714                 MaxBreath        uint16  // Player only.
30715                 EyeHeight        float32 // Player only.
30716                 ZoomFOV          float32 // in degrees. Player only.
30717                 UseTextureAlpha  bool
30718                 DmgTextureMod    Texture // suffix
30719                 Shaded           bool
30720                 ShowOnMinimap    bool
30721                 NametagBG        color.NRGBA
30722         }))(obj)).Visual) = string(local338)
30723         for local340 := range (*(*(struct {
30724                 MaxHP            uint16 // Player only.
30725                 CollideWithNodes bool
30726                 Weight           float32 // deprecated
30727                 ColBox, SelBox   Box
30728                 Pointable        bool
30729                 Visual           string
30730                 VisualSize       [3]float32
30731                 Textures         []Texture
30732                 SpriteSheetSize  [2]int16 // in sprites.
30733                 SpritePos        [2]int16 // in sprite sheet.
30734                 Visible          bool
30735                 MakeFootstepSnds bool
30736                 RotateSpeed      float32 // in radians per second.
30737                 Mesh             string
30738                 Colors           []color.NRGBA
30739                 CollideWithAOs   bool
30740                 StepHeight       float32
30741                 FaceRotateDir    bool
30742                 FaceRotateDirOff float32 // in degrees.
30743                 BackfaceCull     bool
30744                 Nametag          string
30745                 NametagColor     color.NRGBA
30746                 FaceRotateSpeed  float32 // in degrees per second.
30747                 Infotext         string
30748                 Itemstring       string
30749                 Glow             int8
30750                 MaxBreath        uint16  // Player only.
30751                 EyeHeight        float32 // Player only.
30752                 ZoomFOV          float32 // in degrees. Player only.
30753                 UseTextureAlpha  bool
30754                 DmgTextureMod    Texture // suffix
30755                 Shaded           bool
30756                 ShowOnMinimap    bool
30757                 NametagBG        color.NRGBA
30758         }))(obj)).VisualSize {
30759                 {
30760                         p := &((*(*(struct {
30761                                 MaxHP            uint16 // Player only.
30762                                 CollideWithNodes bool
30763                                 Weight           float32 // deprecated
30764                                 ColBox, SelBox   Box
30765                                 Pointable        bool
30766                                 Visual           string
30767                                 VisualSize       [3]float32
30768                                 Textures         []Texture
30769                                 SpriteSheetSize  [2]int16 // in sprites.
30770                                 SpritePos        [2]int16 // in sprite sheet.
30771                                 Visible          bool
30772                                 MakeFootstepSnds bool
30773                                 RotateSpeed      float32 // in radians per second.
30774                                 Mesh             string
30775                                 Colors           []color.NRGBA
30776                                 CollideWithAOs   bool
30777                                 StepHeight       float32
30778                                 FaceRotateDir    bool
30779                                 FaceRotateDirOff float32 // in degrees.
30780                                 BackfaceCull     bool
30781                                 Nametag          string
30782                                 NametagColor     color.NRGBA
30783                                 FaceRotateSpeed  float32 // in degrees per second.
30784                                 Infotext         string
30785                                 Itemstring       string
30786                                 Glow             int8
30787                                 MaxBreath        uint16  // Player only.
30788                                 EyeHeight        float32 // Player only.
30789                                 ZoomFOV          float32 // in degrees. Player only.
30790                                 UseTextureAlpha  bool
30791                                 DmgTextureMod    Texture // suffix
30792                                 Shaded           bool
30793                                 ShowOnMinimap    bool
30794                                 NametagBG        color.NRGBA
30795                         }))(obj)).VisualSize)[local340]
30796                         *p = math.Float32frombits(read32(r))
30797                 }
30798         }
30799         var local341 uint16
30800         {
30801                 p := &local341
30802                 *p = read16(r)
30803         }
30804         ((*(*(struct {
30805                 MaxHP            uint16 // Player only.
30806                 CollideWithNodes bool
30807                 Weight           float32 // deprecated
30808                 ColBox, SelBox   Box
30809                 Pointable        bool
30810                 Visual           string
30811                 VisualSize       [3]float32
30812                 Textures         []Texture
30813                 SpriteSheetSize  [2]int16 // in sprites.
30814                 SpritePos        [2]int16 // in sprite sheet.
30815                 Visible          bool
30816                 MakeFootstepSnds bool
30817                 RotateSpeed      float32 // in radians per second.
30818                 Mesh             string
30819                 Colors           []color.NRGBA
30820                 CollideWithAOs   bool
30821                 StepHeight       float32
30822                 FaceRotateDir    bool
30823                 FaceRotateDirOff float32 // in degrees.
30824                 BackfaceCull     bool
30825                 Nametag          string
30826                 NametagColor     color.NRGBA
30827                 FaceRotateSpeed  float32 // in degrees per second.
30828                 Infotext         string
30829                 Itemstring       string
30830                 Glow             int8
30831                 MaxBreath        uint16  // Player only.
30832                 EyeHeight        float32 // Player only.
30833                 ZoomFOV          float32 // in degrees. Player only.
30834                 UseTextureAlpha  bool
30835                 DmgTextureMod    Texture // suffix
30836                 Shaded           bool
30837                 ShowOnMinimap    bool
30838                 NametagBG        color.NRGBA
30839         }))(obj)).Textures) = make([]Texture, local341)
30840         for local342 := range (*(*(struct {
30841                 MaxHP            uint16 // Player only.
30842                 CollideWithNodes bool
30843                 Weight           float32 // deprecated
30844                 ColBox, SelBox   Box
30845                 Pointable        bool
30846                 Visual           string
30847                 VisualSize       [3]float32
30848                 Textures         []Texture
30849                 SpriteSheetSize  [2]int16 // in sprites.
30850                 SpritePos        [2]int16 // in sprite sheet.
30851                 Visible          bool
30852                 MakeFootstepSnds bool
30853                 RotateSpeed      float32 // in radians per second.
30854                 Mesh             string
30855                 Colors           []color.NRGBA
30856                 CollideWithAOs   bool
30857                 StepHeight       float32
30858                 FaceRotateDir    bool
30859                 FaceRotateDirOff float32 // in degrees.
30860                 BackfaceCull     bool
30861                 Nametag          string
30862                 NametagColor     color.NRGBA
30863                 FaceRotateSpeed  float32 // in degrees per second.
30864                 Infotext         string
30865                 Itemstring       string
30866                 Glow             int8
30867                 MaxBreath        uint16  // Player only.
30868                 EyeHeight        float32 // Player only.
30869                 ZoomFOV          float32 // in degrees. Player only.
30870                 UseTextureAlpha  bool
30871                 DmgTextureMod    Texture // suffix
30872                 Shaded           bool
30873                 ShowOnMinimap    bool
30874                 NametagBG        color.NRGBA
30875         }))(obj)).Textures {
30876                 if err := pcall(func() {
30877                         (((*(*(struct {
30878                                 MaxHP            uint16 // Player only.
30879                                 CollideWithNodes bool
30880                                 Weight           float32 // deprecated
30881                                 ColBox, SelBox   Box
30882                                 Pointable        bool
30883                                 Visual           string
30884                                 VisualSize       [3]float32
30885                                 Textures         []Texture
30886                                 SpriteSheetSize  [2]int16 // in sprites.
30887                                 SpritePos        [2]int16 // in sprite sheet.
30888                                 Visible          bool
30889                                 MakeFootstepSnds bool
30890                                 RotateSpeed      float32 // in radians per second.
30891                                 Mesh             string
30892                                 Colors           []color.NRGBA
30893                                 CollideWithAOs   bool
30894                                 StepHeight       float32
30895                                 FaceRotateDir    bool
30896                                 FaceRotateDirOff float32 // in degrees.
30897                                 BackfaceCull     bool
30898                                 Nametag          string
30899                                 NametagColor     color.NRGBA
30900                                 FaceRotateSpeed  float32 // in degrees per second.
30901                                 Infotext         string
30902                                 Itemstring       string
30903                                 Glow             int8
30904                                 MaxBreath        uint16  // Player only.
30905                                 EyeHeight        float32 // Player only.
30906                                 ZoomFOV          float32 // in degrees. Player only.
30907                                 UseTextureAlpha  bool
30908                                 DmgTextureMod    Texture // suffix
30909                                 Shaded           bool
30910                                 ShowOnMinimap    bool
30911                                 NametagBG        color.NRGBA
30912                         }))(obj)).Textures)[local342]).deserialize(r)
30913                 }); err != nil {
30914                         if err == io.EOF {
30915                                 chk(io.EOF)
30916                         }
30917                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
30918                 }
30919         }
30920         for local343 := range (*(*(struct {
30921                 MaxHP            uint16 // Player only.
30922                 CollideWithNodes bool
30923                 Weight           float32 // deprecated
30924                 ColBox, SelBox   Box
30925                 Pointable        bool
30926                 Visual           string
30927                 VisualSize       [3]float32
30928                 Textures         []Texture
30929                 SpriteSheetSize  [2]int16 // in sprites.
30930                 SpritePos        [2]int16 // in sprite sheet.
30931                 Visible          bool
30932                 MakeFootstepSnds bool
30933                 RotateSpeed      float32 // in radians per second.
30934                 Mesh             string
30935                 Colors           []color.NRGBA
30936                 CollideWithAOs   bool
30937                 StepHeight       float32
30938                 FaceRotateDir    bool
30939                 FaceRotateDirOff float32 // in degrees.
30940                 BackfaceCull     bool
30941                 Nametag          string
30942                 NametagColor     color.NRGBA
30943                 FaceRotateSpeed  float32 // in degrees per second.
30944                 Infotext         string
30945                 Itemstring       string
30946                 Glow             int8
30947                 MaxBreath        uint16  // Player only.
30948                 EyeHeight        float32 // Player only.
30949                 ZoomFOV          float32 // in degrees. Player only.
30950                 UseTextureAlpha  bool
30951                 DmgTextureMod    Texture // suffix
30952                 Shaded           bool
30953                 ShowOnMinimap    bool
30954                 NametagBG        color.NRGBA
30955         }))(obj)).SpriteSheetSize {
30956                 {
30957                         p := &((*(*(struct {
30958                                 MaxHP            uint16 // Player only.
30959                                 CollideWithNodes bool
30960                                 Weight           float32 // deprecated
30961                                 ColBox, SelBox   Box
30962                                 Pointable        bool
30963                                 Visual           string
30964                                 VisualSize       [3]float32
30965                                 Textures         []Texture
30966                                 SpriteSheetSize  [2]int16 // in sprites.
30967                                 SpritePos        [2]int16 // in sprite sheet.
30968                                 Visible          bool
30969                                 MakeFootstepSnds bool
30970                                 RotateSpeed      float32 // in radians per second.
30971                                 Mesh             string
30972                                 Colors           []color.NRGBA
30973                                 CollideWithAOs   bool
30974                                 StepHeight       float32
30975                                 FaceRotateDir    bool
30976                                 FaceRotateDirOff float32 // in degrees.
30977                                 BackfaceCull     bool
30978                                 Nametag          string
30979                                 NametagColor     color.NRGBA
30980                                 FaceRotateSpeed  float32 // in degrees per second.
30981                                 Infotext         string
30982                                 Itemstring       string
30983                                 Glow             int8
30984                                 MaxBreath        uint16  // Player only.
30985                                 EyeHeight        float32 // Player only.
30986                                 ZoomFOV          float32 // in degrees. Player only.
30987                                 UseTextureAlpha  bool
30988                                 DmgTextureMod    Texture // suffix
30989                                 Shaded           bool
30990                                 ShowOnMinimap    bool
30991                                 NametagBG        color.NRGBA
30992                         }))(obj)).SpriteSheetSize)[local343]
30993                         *p = int16(read16(r))
30994                 }
30995         }
30996         for local344 := range (*(*(struct {
30997                 MaxHP            uint16 // Player only.
30998                 CollideWithNodes bool
30999                 Weight           float32 // deprecated
31000                 ColBox, SelBox   Box
31001                 Pointable        bool
31002                 Visual           string
31003                 VisualSize       [3]float32
31004                 Textures         []Texture
31005                 SpriteSheetSize  [2]int16 // in sprites.
31006                 SpritePos        [2]int16 // in sprite sheet.
31007                 Visible          bool
31008                 MakeFootstepSnds bool
31009                 RotateSpeed      float32 // in radians per second.
31010                 Mesh             string
31011                 Colors           []color.NRGBA
31012                 CollideWithAOs   bool
31013                 StepHeight       float32
31014                 FaceRotateDir    bool
31015                 FaceRotateDirOff float32 // in degrees.
31016                 BackfaceCull     bool
31017                 Nametag          string
31018                 NametagColor     color.NRGBA
31019                 FaceRotateSpeed  float32 // in degrees per second.
31020                 Infotext         string
31021                 Itemstring       string
31022                 Glow             int8
31023                 MaxBreath        uint16  // Player only.
31024                 EyeHeight        float32 // Player only.
31025                 ZoomFOV          float32 // in degrees. Player only.
31026                 UseTextureAlpha  bool
31027                 DmgTextureMod    Texture // suffix
31028                 Shaded           bool
31029                 ShowOnMinimap    bool
31030                 NametagBG        color.NRGBA
31031         }))(obj)).SpritePos {
31032                 {
31033                         p := &((*(*(struct {
31034                                 MaxHP            uint16 // Player only.
31035                                 CollideWithNodes bool
31036                                 Weight           float32 // deprecated
31037                                 ColBox, SelBox   Box
31038                                 Pointable        bool
31039                                 Visual           string
31040                                 VisualSize       [3]float32
31041                                 Textures         []Texture
31042                                 SpriteSheetSize  [2]int16 // in sprites.
31043                                 SpritePos        [2]int16 // in sprite sheet.
31044                                 Visible          bool
31045                                 MakeFootstepSnds bool
31046                                 RotateSpeed      float32 // in radians per second.
31047                                 Mesh             string
31048                                 Colors           []color.NRGBA
31049                                 CollideWithAOs   bool
31050                                 StepHeight       float32
31051                                 FaceRotateDir    bool
31052                                 FaceRotateDirOff float32 // in degrees.
31053                                 BackfaceCull     bool
31054                                 Nametag          string
31055                                 NametagColor     color.NRGBA
31056                                 FaceRotateSpeed  float32 // in degrees per second.
31057                                 Infotext         string
31058                                 Itemstring       string
31059                                 Glow             int8
31060                                 MaxBreath        uint16  // Player only.
31061                                 EyeHeight        float32 // Player only.
31062                                 ZoomFOV          float32 // in degrees. Player only.
31063                                 UseTextureAlpha  bool
31064                                 DmgTextureMod    Texture // suffix
31065                                 Shaded           bool
31066                                 ShowOnMinimap    bool
31067                                 NametagBG        color.NRGBA
31068                         }))(obj)).SpritePos)[local344]
31069                         *p = int16(read16(r))
31070                 }
31071         }
31072         {
31073                 p := &(*(*(struct {
31074                         MaxHP            uint16 // Player only.
31075                         CollideWithNodes bool
31076                         Weight           float32 // deprecated
31077                         ColBox, SelBox   Box
31078                         Pointable        bool
31079                         Visual           string
31080                         VisualSize       [3]float32
31081                         Textures         []Texture
31082                         SpriteSheetSize  [2]int16 // in sprites.
31083                         SpritePos        [2]int16 // in sprite sheet.
31084                         Visible          bool
31085                         MakeFootstepSnds bool
31086                         RotateSpeed      float32 // in radians per second.
31087                         Mesh             string
31088                         Colors           []color.NRGBA
31089                         CollideWithAOs   bool
31090                         StepHeight       float32
31091                         FaceRotateDir    bool
31092                         FaceRotateDirOff float32 // in degrees.
31093                         BackfaceCull     bool
31094                         Nametag          string
31095                         NametagColor     color.NRGBA
31096                         FaceRotateSpeed  float32 // in degrees per second.
31097                         Infotext         string
31098                         Itemstring       string
31099                         Glow             int8
31100                         MaxBreath        uint16  // Player only.
31101                         EyeHeight        float32 // Player only.
31102                         ZoomFOV          float32 // in degrees. Player only.
31103                         UseTextureAlpha  bool
31104                         DmgTextureMod    Texture // suffix
31105                         Shaded           bool
31106                         ShowOnMinimap    bool
31107                         NametagBG        color.NRGBA
31108                 }))(obj)).Visible
31109                 switch n := read8(r); n {
31110                 case 0:
31111                         *p = false
31112                 case 1:
31113                         *p = true
31114                 default:
31115                         chk(fmt.Errorf("invalid bool: %d", n))
31116                 }
31117         }
31118         {
31119                 p := &(*(*(struct {
31120                         MaxHP            uint16 // Player only.
31121                         CollideWithNodes bool
31122                         Weight           float32 // deprecated
31123                         ColBox, SelBox   Box
31124                         Pointable        bool
31125                         Visual           string
31126                         VisualSize       [3]float32
31127                         Textures         []Texture
31128                         SpriteSheetSize  [2]int16 // in sprites.
31129                         SpritePos        [2]int16 // in sprite sheet.
31130                         Visible          bool
31131                         MakeFootstepSnds bool
31132                         RotateSpeed      float32 // in radians per second.
31133                         Mesh             string
31134                         Colors           []color.NRGBA
31135                         CollideWithAOs   bool
31136                         StepHeight       float32
31137                         FaceRotateDir    bool
31138                         FaceRotateDirOff float32 // in degrees.
31139                         BackfaceCull     bool
31140                         Nametag          string
31141                         NametagColor     color.NRGBA
31142                         FaceRotateSpeed  float32 // in degrees per second.
31143                         Infotext         string
31144                         Itemstring       string
31145                         Glow             int8
31146                         MaxBreath        uint16  // Player only.
31147                         EyeHeight        float32 // Player only.
31148                         ZoomFOV          float32 // in degrees. Player only.
31149                         UseTextureAlpha  bool
31150                         DmgTextureMod    Texture // suffix
31151                         Shaded           bool
31152                         ShowOnMinimap    bool
31153                         NametagBG        color.NRGBA
31154                 }))(obj)).MakeFootstepSnds
31155                 switch n := read8(r); n {
31156                 case 0:
31157                         *p = false
31158                 case 1:
31159                         *p = true
31160                 default:
31161                         chk(fmt.Errorf("invalid bool: %d", n))
31162                 }
31163         }
31164         {
31165                 p := &(*(*(struct {
31166                         MaxHP            uint16 // Player only.
31167                         CollideWithNodes bool
31168                         Weight           float32 // deprecated
31169                         ColBox, SelBox   Box
31170                         Pointable        bool
31171                         Visual           string
31172                         VisualSize       [3]float32
31173                         Textures         []Texture
31174                         SpriteSheetSize  [2]int16 // in sprites.
31175                         SpritePos        [2]int16 // in sprite sheet.
31176                         Visible          bool
31177                         MakeFootstepSnds bool
31178                         RotateSpeed      float32 // in radians per second.
31179                         Mesh             string
31180                         Colors           []color.NRGBA
31181                         CollideWithAOs   bool
31182                         StepHeight       float32
31183                         FaceRotateDir    bool
31184                         FaceRotateDirOff float32 // in degrees.
31185                         BackfaceCull     bool
31186                         Nametag          string
31187                         NametagColor     color.NRGBA
31188                         FaceRotateSpeed  float32 // in degrees per second.
31189                         Infotext         string
31190                         Itemstring       string
31191                         Glow             int8
31192                         MaxBreath        uint16  // Player only.
31193                         EyeHeight        float32 // Player only.
31194                         ZoomFOV          float32 // in degrees. Player only.
31195                         UseTextureAlpha  bool
31196                         DmgTextureMod    Texture // suffix
31197                         Shaded           bool
31198                         ShowOnMinimap    bool
31199                         NametagBG        color.NRGBA
31200                 }))(obj)).RotateSpeed
31201                 *p = math.Float32frombits(read32(r))
31202         }
31203         var local345 []uint8
31204         var local346 uint16
31205         {
31206                 p := &local346
31207                 *p = read16(r)
31208         }
31209         (local345) = make([]uint8, local346)
31210         {
31211                 _, err := io.ReadFull(r, (local345)[:])
31212                 chk(err)
31213         }
31214         ((*(*(struct {
31215                 MaxHP            uint16 // Player only.
31216                 CollideWithNodes bool
31217                 Weight           float32 // deprecated
31218                 ColBox, SelBox   Box
31219                 Pointable        bool
31220                 Visual           string
31221                 VisualSize       [3]float32
31222                 Textures         []Texture
31223                 SpriteSheetSize  [2]int16 // in sprites.
31224                 SpritePos        [2]int16 // in sprite sheet.
31225                 Visible          bool
31226                 MakeFootstepSnds bool
31227                 RotateSpeed      float32 // in radians per second.
31228                 Mesh             string
31229                 Colors           []color.NRGBA
31230                 CollideWithAOs   bool
31231                 StepHeight       float32
31232                 FaceRotateDir    bool
31233                 FaceRotateDirOff float32 // in degrees.
31234                 BackfaceCull     bool
31235                 Nametag          string
31236                 NametagColor     color.NRGBA
31237                 FaceRotateSpeed  float32 // in degrees per second.
31238                 Infotext         string
31239                 Itemstring       string
31240                 Glow             int8
31241                 MaxBreath        uint16  // Player only.
31242                 EyeHeight        float32 // Player only.
31243                 ZoomFOV          float32 // in degrees. Player only.
31244                 UseTextureAlpha  bool
31245                 DmgTextureMod    Texture // suffix
31246                 Shaded           bool
31247                 ShowOnMinimap    bool
31248                 NametagBG        color.NRGBA
31249         }))(obj)).Mesh) = string(local345)
31250         var local347 uint16
31251         {
31252                 p := &local347
31253                 *p = read16(r)
31254         }
31255         ((*(*(struct {
31256                 MaxHP            uint16 // Player only.
31257                 CollideWithNodes bool
31258                 Weight           float32 // deprecated
31259                 ColBox, SelBox   Box
31260                 Pointable        bool
31261                 Visual           string
31262                 VisualSize       [3]float32
31263                 Textures         []Texture
31264                 SpriteSheetSize  [2]int16 // in sprites.
31265                 SpritePos        [2]int16 // in sprite sheet.
31266                 Visible          bool
31267                 MakeFootstepSnds bool
31268                 RotateSpeed      float32 // in radians per second.
31269                 Mesh             string
31270                 Colors           []color.NRGBA
31271                 CollideWithAOs   bool
31272                 StepHeight       float32
31273                 FaceRotateDir    bool
31274                 FaceRotateDirOff float32 // in degrees.
31275                 BackfaceCull     bool
31276                 Nametag          string
31277                 NametagColor     color.NRGBA
31278                 FaceRotateSpeed  float32 // in degrees per second.
31279                 Infotext         string
31280                 Itemstring       string
31281                 Glow             int8
31282                 MaxBreath        uint16  // Player only.
31283                 EyeHeight        float32 // Player only.
31284                 ZoomFOV          float32 // in degrees. Player only.
31285                 UseTextureAlpha  bool
31286                 DmgTextureMod    Texture // suffix
31287                 Shaded           bool
31288                 ShowOnMinimap    bool
31289                 NametagBG        color.NRGBA
31290         }))(obj)).Colors) = make([]color.NRGBA, local347)
31291         for local348 := range (*(*(struct {
31292                 MaxHP            uint16 // Player only.
31293                 CollideWithNodes bool
31294                 Weight           float32 // deprecated
31295                 ColBox, SelBox   Box
31296                 Pointable        bool
31297                 Visual           string
31298                 VisualSize       [3]float32
31299                 Textures         []Texture
31300                 SpriteSheetSize  [2]int16 // in sprites.
31301                 SpritePos        [2]int16 // in sprite sheet.
31302                 Visible          bool
31303                 MakeFootstepSnds bool
31304                 RotateSpeed      float32 // in radians per second.
31305                 Mesh             string
31306                 Colors           []color.NRGBA
31307                 CollideWithAOs   bool
31308                 StepHeight       float32
31309                 FaceRotateDir    bool
31310                 FaceRotateDirOff float32 // in degrees.
31311                 BackfaceCull     bool
31312                 Nametag          string
31313                 NametagColor     color.NRGBA
31314                 FaceRotateSpeed  float32 // in degrees per second.
31315                 Infotext         string
31316                 Itemstring       string
31317                 Glow             int8
31318                 MaxBreath        uint16  // Player only.
31319                 EyeHeight        float32 // Player only.
31320                 ZoomFOV          float32 // in degrees. Player only.
31321                 UseTextureAlpha  bool
31322                 DmgTextureMod    Texture // suffix
31323                 Shaded           bool
31324                 ShowOnMinimap    bool
31325                 NametagBG        color.NRGBA
31326         }))(obj)).Colors {
31327                 {
31328                         p := &((*(*(struct {
31329                                 MaxHP            uint16 // Player only.
31330                                 CollideWithNodes bool
31331                                 Weight           float32 // deprecated
31332                                 ColBox, SelBox   Box
31333                                 Pointable        bool
31334                                 Visual           string
31335                                 VisualSize       [3]float32
31336                                 Textures         []Texture
31337                                 SpriteSheetSize  [2]int16 // in sprites.
31338                                 SpritePos        [2]int16 // in sprite sheet.
31339                                 Visible          bool
31340                                 MakeFootstepSnds bool
31341                                 RotateSpeed      float32 // in radians per second.
31342                                 Mesh             string
31343                                 Colors           []color.NRGBA
31344                                 CollideWithAOs   bool
31345                                 StepHeight       float32
31346                                 FaceRotateDir    bool
31347                                 FaceRotateDirOff float32 // in degrees.
31348                                 BackfaceCull     bool
31349                                 Nametag          string
31350                                 NametagColor     color.NRGBA
31351                                 FaceRotateSpeed  float32 // in degrees per second.
31352                                 Infotext         string
31353                                 Itemstring       string
31354                                 Glow             int8
31355                                 MaxBreath        uint16  // Player only.
31356                                 EyeHeight        float32 // Player only.
31357                                 ZoomFOV          float32 // in degrees. Player only.
31358                                 UseTextureAlpha  bool
31359                                 DmgTextureMod    Texture // suffix
31360                                 Shaded           bool
31361                                 ShowOnMinimap    bool
31362                                 NametagBG        color.NRGBA
31363                         }))(obj)).Colors)[local348]
31364                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31365                 }
31366         }
31367         {
31368                 p := &(*(*(struct {
31369                         MaxHP            uint16 // Player only.
31370                         CollideWithNodes bool
31371                         Weight           float32 // deprecated
31372                         ColBox, SelBox   Box
31373                         Pointable        bool
31374                         Visual           string
31375                         VisualSize       [3]float32
31376                         Textures         []Texture
31377                         SpriteSheetSize  [2]int16 // in sprites.
31378                         SpritePos        [2]int16 // in sprite sheet.
31379                         Visible          bool
31380                         MakeFootstepSnds bool
31381                         RotateSpeed      float32 // in radians per second.
31382                         Mesh             string
31383                         Colors           []color.NRGBA
31384                         CollideWithAOs   bool
31385                         StepHeight       float32
31386                         FaceRotateDir    bool
31387                         FaceRotateDirOff float32 // in degrees.
31388                         BackfaceCull     bool
31389                         Nametag          string
31390                         NametagColor     color.NRGBA
31391                         FaceRotateSpeed  float32 // in degrees per second.
31392                         Infotext         string
31393                         Itemstring       string
31394                         Glow             int8
31395                         MaxBreath        uint16  // Player only.
31396                         EyeHeight        float32 // Player only.
31397                         ZoomFOV          float32 // in degrees. Player only.
31398                         UseTextureAlpha  bool
31399                         DmgTextureMod    Texture // suffix
31400                         Shaded           bool
31401                         ShowOnMinimap    bool
31402                         NametagBG        color.NRGBA
31403                 }))(obj)).CollideWithAOs
31404                 switch n := read8(r); n {
31405                 case 0:
31406                         *p = false
31407                 case 1:
31408                         *p = true
31409                 default:
31410                         chk(fmt.Errorf("invalid bool: %d", n))
31411                 }
31412         }
31413         {
31414                 p := &(*(*(struct {
31415                         MaxHP            uint16 // Player only.
31416                         CollideWithNodes bool
31417                         Weight           float32 // deprecated
31418                         ColBox, SelBox   Box
31419                         Pointable        bool
31420                         Visual           string
31421                         VisualSize       [3]float32
31422                         Textures         []Texture
31423                         SpriteSheetSize  [2]int16 // in sprites.
31424                         SpritePos        [2]int16 // in sprite sheet.
31425                         Visible          bool
31426                         MakeFootstepSnds bool
31427                         RotateSpeed      float32 // in radians per second.
31428                         Mesh             string
31429                         Colors           []color.NRGBA
31430                         CollideWithAOs   bool
31431                         StepHeight       float32
31432                         FaceRotateDir    bool
31433                         FaceRotateDirOff float32 // in degrees.
31434                         BackfaceCull     bool
31435                         Nametag          string
31436                         NametagColor     color.NRGBA
31437                         FaceRotateSpeed  float32 // in degrees per second.
31438                         Infotext         string
31439                         Itemstring       string
31440                         Glow             int8
31441                         MaxBreath        uint16  // Player only.
31442                         EyeHeight        float32 // Player only.
31443                         ZoomFOV          float32 // in degrees. Player only.
31444                         UseTextureAlpha  bool
31445                         DmgTextureMod    Texture // suffix
31446                         Shaded           bool
31447                         ShowOnMinimap    bool
31448                         NametagBG        color.NRGBA
31449                 }))(obj)).StepHeight
31450                 *p = math.Float32frombits(read32(r))
31451         }
31452         {
31453                 p := &(*(*(struct {
31454                         MaxHP            uint16 // Player only.
31455                         CollideWithNodes bool
31456                         Weight           float32 // deprecated
31457                         ColBox, SelBox   Box
31458                         Pointable        bool
31459                         Visual           string
31460                         VisualSize       [3]float32
31461                         Textures         []Texture
31462                         SpriteSheetSize  [2]int16 // in sprites.
31463                         SpritePos        [2]int16 // in sprite sheet.
31464                         Visible          bool
31465                         MakeFootstepSnds bool
31466                         RotateSpeed      float32 // in radians per second.
31467                         Mesh             string
31468                         Colors           []color.NRGBA
31469                         CollideWithAOs   bool
31470                         StepHeight       float32
31471                         FaceRotateDir    bool
31472                         FaceRotateDirOff float32 // in degrees.
31473                         BackfaceCull     bool
31474                         Nametag          string
31475                         NametagColor     color.NRGBA
31476                         FaceRotateSpeed  float32 // in degrees per second.
31477                         Infotext         string
31478                         Itemstring       string
31479                         Glow             int8
31480                         MaxBreath        uint16  // Player only.
31481                         EyeHeight        float32 // Player only.
31482                         ZoomFOV          float32 // in degrees. Player only.
31483                         UseTextureAlpha  bool
31484                         DmgTextureMod    Texture // suffix
31485                         Shaded           bool
31486                         ShowOnMinimap    bool
31487                         NametagBG        color.NRGBA
31488                 }))(obj)).FaceRotateDir
31489                 switch n := read8(r); n {
31490                 case 0:
31491                         *p = false
31492                 case 1:
31493                         *p = true
31494                 default:
31495                         chk(fmt.Errorf("invalid bool: %d", n))
31496                 }
31497         }
31498         {
31499                 p := &(*(*(struct {
31500                         MaxHP            uint16 // Player only.
31501                         CollideWithNodes bool
31502                         Weight           float32 // deprecated
31503                         ColBox, SelBox   Box
31504                         Pointable        bool
31505                         Visual           string
31506                         VisualSize       [3]float32
31507                         Textures         []Texture
31508                         SpriteSheetSize  [2]int16 // in sprites.
31509                         SpritePos        [2]int16 // in sprite sheet.
31510                         Visible          bool
31511                         MakeFootstepSnds bool
31512                         RotateSpeed      float32 // in radians per second.
31513                         Mesh             string
31514                         Colors           []color.NRGBA
31515                         CollideWithAOs   bool
31516                         StepHeight       float32
31517                         FaceRotateDir    bool
31518                         FaceRotateDirOff float32 // in degrees.
31519                         BackfaceCull     bool
31520                         Nametag          string
31521                         NametagColor     color.NRGBA
31522                         FaceRotateSpeed  float32 // in degrees per second.
31523                         Infotext         string
31524                         Itemstring       string
31525                         Glow             int8
31526                         MaxBreath        uint16  // Player only.
31527                         EyeHeight        float32 // Player only.
31528                         ZoomFOV          float32 // in degrees. Player only.
31529                         UseTextureAlpha  bool
31530                         DmgTextureMod    Texture // suffix
31531                         Shaded           bool
31532                         ShowOnMinimap    bool
31533                         NametagBG        color.NRGBA
31534                 }))(obj)).FaceRotateDirOff
31535                 *p = math.Float32frombits(read32(r))
31536         }
31537         {
31538                 p := &(*(*(struct {
31539                         MaxHP            uint16 // Player only.
31540                         CollideWithNodes bool
31541                         Weight           float32 // deprecated
31542                         ColBox, SelBox   Box
31543                         Pointable        bool
31544                         Visual           string
31545                         VisualSize       [3]float32
31546                         Textures         []Texture
31547                         SpriteSheetSize  [2]int16 // in sprites.
31548                         SpritePos        [2]int16 // in sprite sheet.
31549                         Visible          bool
31550                         MakeFootstepSnds bool
31551                         RotateSpeed      float32 // in radians per second.
31552                         Mesh             string
31553                         Colors           []color.NRGBA
31554                         CollideWithAOs   bool
31555                         StepHeight       float32
31556                         FaceRotateDir    bool
31557                         FaceRotateDirOff float32 // in degrees.
31558                         BackfaceCull     bool
31559                         Nametag          string
31560                         NametagColor     color.NRGBA
31561                         FaceRotateSpeed  float32 // in degrees per second.
31562                         Infotext         string
31563                         Itemstring       string
31564                         Glow             int8
31565                         MaxBreath        uint16  // Player only.
31566                         EyeHeight        float32 // Player only.
31567                         ZoomFOV          float32 // in degrees. Player only.
31568                         UseTextureAlpha  bool
31569                         DmgTextureMod    Texture // suffix
31570                         Shaded           bool
31571                         ShowOnMinimap    bool
31572                         NametagBG        color.NRGBA
31573                 }))(obj)).BackfaceCull
31574                 switch n := read8(r); n {
31575                 case 0:
31576                         *p = false
31577                 case 1:
31578                         *p = true
31579                 default:
31580                         chk(fmt.Errorf("invalid bool: %d", n))
31581                 }
31582         }
31583         var local349 []uint8
31584         var local350 uint16
31585         {
31586                 p := &local350
31587                 *p = read16(r)
31588         }
31589         (local349) = make([]uint8, local350)
31590         {
31591                 _, err := io.ReadFull(r, (local349)[:])
31592                 chk(err)
31593         }
31594         ((*(*(struct {
31595                 MaxHP            uint16 // Player only.
31596                 CollideWithNodes bool
31597                 Weight           float32 // deprecated
31598                 ColBox, SelBox   Box
31599                 Pointable        bool
31600                 Visual           string
31601                 VisualSize       [3]float32
31602                 Textures         []Texture
31603                 SpriteSheetSize  [2]int16 // in sprites.
31604                 SpritePos        [2]int16 // in sprite sheet.
31605                 Visible          bool
31606                 MakeFootstepSnds bool
31607                 RotateSpeed      float32 // in radians per second.
31608                 Mesh             string
31609                 Colors           []color.NRGBA
31610                 CollideWithAOs   bool
31611                 StepHeight       float32
31612                 FaceRotateDir    bool
31613                 FaceRotateDirOff float32 // in degrees.
31614                 BackfaceCull     bool
31615                 Nametag          string
31616                 NametagColor     color.NRGBA
31617                 FaceRotateSpeed  float32 // in degrees per second.
31618                 Infotext         string
31619                 Itemstring       string
31620                 Glow             int8
31621                 MaxBreath        uint16  // Player only.
31622                 EyeHeight        float32 // Player only.
31623                 ZoomFOV          float32 // in degrees. Player only.
31624                 UseTextureAlpha  bool
31625                 DmgTextureMod    Texture // suffix
31626                 Shaded           bool
31627                 ShowOnMinimap    bool
31628                 NametagBG        color.NRGBA
31629         }))(obj)).Nametag) = string(local349)
31630         {
31631                 p := &(*(*(struct {
31632                         MaxHP            uint16 // Player only.
31633                         CollideWithNodes bool
31634                         Weight           float32 // deprecated
31635                         ColBox, SelBox   Box
31636                         Pointable        bool
31637                         Visual           string
31638                         VisualSize       [3]float32
31639                         Textures         []Texture
31640                         SpriteSheetSize  [2]int16 // in sprites.
31641                         SpritePos        [2]int16 // in sprite sheet.
31642                         Visible          bool
31643                         MakeFootstepSnds bool
31644                         RotateSpeed      float32 // in radians per second.
31645                         Mesh             string
31646                         Colors           []color.NRGBA
31647                         CollideWithAOs   bool
31648                         StepHeight       float32
31649                         FaceRotateDir    bool
31650                         FaceRotateDirOff float32 // in degrees.
31651                         BackfaceCull     bool
31652                         Nametag          string
31653                         NametagColor     color.NRGBA
31654                         FaceRotateSpeed  float32 // in degrees per second.
31655                         Infotext         string
31656                         Itemstring       string
31657                         Glow             int8
31658                         MaxBreath        uint16  // Player only.
31659                         EyeHeight        float32 // Player only.
31660                         ZoomFOV          float32 // in degrees. Player only.
31661                         UseTextureAlpha  bool
31662                         DmgTextureMod    Texture // suffix
31663                         Shaded           bool
31664                         ShowOnMinimap    bool
31665                         NametagBG        color.NRGBA
31666                 }))(obj)).NametagColor
31667                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31668         }
31669         {
31670                 p := &(*(*(struct {
31671                         MaxHP            uint16 // Player only.
31672                         CollideWithNodes bool
31673                         Weight           float32 // deprecated
31674                         ColBox, SelBox   Box
31675                         Pointable        bool
31676                         Visual           string
31677                         VisualSize       [3]float32
31678                         Textures         []Texture
31679                         SpriteSheetSize  [2]int16 // in sprites.
31680                         SpritePos        [2]int16 // in sprite sheet.
31681                         Visible          bool
31682                         MakeFootstepSnds bool
31683                         RotateSpeed      float32 // in radians per second.
31684                         Mesh             string
31685                         Colors           []color.NRGBA
31686                         CollideWithAOs   bool
31687                         StepHeight       float32
31688                         FaceRotateDir    bool
31689                         FaceRotateDirOff float32 // in degrees.
31690                         BackfaceCull     bool
31691                         Nametag          string
31692                         NametagColor     color.NRGBA
31693                         FaceRotateSpeed  float32 // in degrees per second.
31694                         Infotext         string
31695                         Itemstring       string
31696                         Glow             int8
31697                         MaxBreath        uint16  // Player only.
31698                         EyeHeight        float32 // Player only.
31699                         ZoomFOV          float32 // in degrees. Player only.
31700                         UseTextureAlpha  bool
31701                         DmgTextureMod    Texture // suffix
31702                         Shaded           bool
31703                         ShowOnMinimap    bool
31704                         NametagBG        color.NRGBA
31705                 }))(obj)).FaceRotateSpeed
31706                 *p = math.Float32frombits(read32(r))
31707         }
31708         var local351 []uint8
31709         var local352 uint16
31710         {
31711                 p := &local352
31712                 *p = read16(r)
31713         }
31714         (local351) = make([]uint8, local352)
31715         {
31716                 _, err := io.ReadFull(r, (local351)[:])
31717                 chk(err)
31718         }
31719         ((*(*(struct {
31720                 MaxHP            uint16 // Player only.
31721                 CollideWithNodes bool
31722                 Weight           float32 // deprecated
31723                 ColBox, SelBox   Box
31724                 Pointable        bool
31725                 Visual           string
31726                 VisualSize       [3]float32
31727                 Textures         []Texture
31728                 SpriteSheetSize  [2]int16 // in sprites.
31729                 SpritePos        [2]int16 // in sprite sheet.
31730                 Visible          bool
31731                 MakeFootstepSnds bool
31732                 RotateSpeed      float32 // in radians per second.
31733                 Mesh             string
31734                 Colors           []color.NRGBA
31735                 CollideWithAOs   bool
31736                 StepHeight       float32
31737                 FaceRotateDir    bool
31738                 FaceRotateDirOff float32 // in degrees.
31739                 BackfaceCull     bool
31740                 Nametag          string
31741                 NametagColor     color.NRGBA
31742                 FaceRotateSpeed  float32 // in degrees per second.
31743                 Infotext         string
31744                 Itemstring       string
31745                 Glow             int8
31746                 MaxBreath        uint16  // Player only.
31747                 EyeHeight        float32 // Player only.
31748                 ZoomFOV          float32 // in degrees. Player only.
31749                 UseTextureAlpha  bool
31750                 DmgTextureMod    Texture // suffix
31751                 Shaded           bool
31752                 ShowOnMinimap    bool
31753                 NametagBG        color.NRGBA
31754         }))(obj)).Infotext) = string(local351)
31755         var local353 []uint8
31756         var local354 uint16
31757         {
31758                 p := &local354
31759                 *p = read16(r)
31760         }
31761         (local353) = make([]uint8, local354)
31762         {
31763                 _, err := io.ReadFull(r, (local353)[:])
31764                 chk(err)
31765         }
31766         ((*(*(struct {
31767                 MaxHP            uint16 // Player only.
31768                 CollideWithNodes bool
31769                 Weight           float32 // deprecated
31770                 ColBox, SelBox   Box
31771                 Pointable        bool
31772                 Visual           string
31773                 VisualSize       [3]float32
31774                 Textures         []Texture
31775                 SpriteSheetSize  [2]int16 // in sprites.
31776                 SpritePos        [2]int16 // in sprite sheet.
31777                 Visible          bool
31778                 MakeFootstepSnds bool
31779                 RotateSpeed      float32 // in radians per second.
31780                 Mesh             string
31781                 Colors           []color.NRGBA
31782                 CollideWithAOs   bool
31783                 StepHeight       float32
31784                 FaceRotateDir    bool
31785                 FaceRotateDirOff float32 // in degrees.
31786                 BackfaceCull     bool
31787                 Nametag          string
31788                 NametagColor     color.NRGBA
31789                 FaceRotateSpeed  float32 // in degrees per second.
31790                 Infotext         string
31791                 Itemstring       string
31792                 Glow             int8
31793                 MaxBreath        uint16  // Player only.
31794                 EyeHeight        float32 // Player only.
31795                 ZoomFOV          float32 // in degrees. Player only.
31796                 UseTextureAlpha  bool
31797                 DmgTextureMod    Texture // suffix
31798                 Shaded           bool
31799                 ShowOnMinimap    bool
31800                 NametagBG        color.NRGBA
31801         }))(obj)).Itemstring) = string(local353)
31802         {
31803                 p := &(*(*(struct {
31804                         MaxHP            uint16 // Player only.
31805                         CollideWithNodes bool
31806                         Weight           float32 // deprecated
31807                         ColBox, SelBox   Box
31808                         Pointable        bool
31809                         Visual           string
31810                         VisualSize       [3]float32
31811                         Textures         []Texture
31812                         SpriteSheetSize  [2]int16 // in sprites.
31813                         SpritePos        [2]int16 // in sprite sheet.
31814                         Visible          bool
31815                         MakeFootstepSnds bool
31816                         RotateSpeed      float32 // in radians per second.
31817                         Mesh             string
31818                         Colors           []color.NRGBA
31819                         CollideWithAOs   bool
31820                         StepHeight       float32
31821                         FaceRotateDir    bool
31822                         FaceRotateDirOff float32 // in degrees.
31823                         BackfaceCull     bool
31824                         Nametag          string
31825                         NametagColor     color.NRGBA
31826                         FaceRotateSpeed  float32 // in degrees per second.
31827                         Infotext         string
31828                         Itemstring       string
31829                         Glow             int8
31830                         MaxBreath        uint16  // Player only.
31831                         EyeHeight        float32 // Player only.
31832                         ZoomFOV          float32 // in degrees. Player only.
31833                         UseTextureAlpha  bool
31834                         DmgTextureMod    Texture // suffix
31835                         Shaded           bool
31836                         ShowOnMinimap    bool
31837                         NametagBG        color.NRGBA
31838                 }))(obj)).Glow
31839                 *p = int8(read8(r))
31840         }
31841         {
31842                 p := &(*(*(struct {
31843                         MaxHP            uint16 // Player only.
31844                         CollideWithNodes bool
31845                         Weight           float32 // deprecated
31846                         ColBox, SelBox   Box
31847                         Pointable        bool
31848                         Visual           string
31849                         VisualSize       [3]float32
31850                         Textures         []Texture
31851                         SpriteSheetSize  [2]int16 // in sprites.
31852                         SpritePos        [2]int16 // in sprite sheet.
31853                         Visible          bool
31854                         MakeFootstepSnds bool
31855                         RotateSpeed      float32 // in radians per second.
31856                         Mesh             string
31857                         Colors           []color.NRGBA
31858                         CollideWithAOs   bool
31859                         StepHeight       float32
31860                         FaceRotateDir    bool
31861                         FaceRotateDirOff float32 // in degrees.
31862                         BackfaceCull     bool
31863                         Nametag          string
31864                         NametagColor     color.NRGBA
31865                         FaceRotateSpeed  float32 // in degrees per second.
31866                         Infotext         string
31867                         Itemstring       string
31868                         Glow             int8
31869                         MaxBreath        uint16  // Player only.
31870                         EyeHeight        float32 // Player only.
31871                         ZoomFOV          float32 // in degrees. Player only.
31872                         UseTextureAlpha  bool
31873                         DmgTextureMod    Texture // suffix
31874                         Shaded           bool
31875                         ShowOnMinimap    bool
31876                         NametagBG        color.NRGBA
31877                 }))(obj)).MaxBreath
31878                 *p = read16(r)
31879         }
31880         {
31881                 p := &(*(*(struct {
31882                         MaxHP            uint16 // Player only.
31883                         CollideWithNodes bool
31884                         Weight           float32 // deprecated
31885                         ColBox, SelBox   Box
31886                         Pointable        bool
31887                         Visual           string
31888                         VisualSize       [3]float32
31889                         Textures         []Texture
31890                         SpriteSheetSize  [2]int16 // in sprites.
31891                         SpritePos        [2]int16 // in sprite sheet.
31892                         Visible          bool
31893                         MakeFootstepSnds bool
31894                         RotateSpeed      float32 // in radians per second.
31895                         Mesh             string
31896                         Colors           []color.NRGBA
31897                         CollideWithAOs   bool
31898                         StepHeight       float32
31899                         FaceRotateDir    bool
31900                         FaceRotateDirOff float32 // in degrees.
31901                         BackfaceCull     bool
31902                         Nametag          string
31903                         NametagColor     color.NRGBA
31904                         FaceRotateSpeed  float32 // in degrees per second.
31905                         Infotext         string
31906                         Itemstring       string
31907                         Glow             int8
31908                         MaxBreath        uint16  // Player only.
31909                         EyeHeight        float32 // Player only.
31910                         ZoomFOV          float32 // in degrees. Player only.
31911                         UseTextureAlpha  bool
31912                         DmgTextureMod    Texture // suffix
31913                         Shaded           bool
31914                         ShowOnMinimap    bool
31915                         NametagBG        color.NRGBA
31916                 }))(obj)).EyeHeight
31917                 *p = math.Float32frombits(read32(r))
31918         }
31919         {
31920                 p := &(*(*(struct {
31921                         MaxHP            uint16 // Player only.
31922                         CollideWithNodes bool
31923                         Weight           float32 // deprecated
31924                         ColBox, SelBox   Box
31925                         Pointable        bool
31926                         Visual           string
31927                         VisualSize       [3]float32
31928                         Textures         []Texture
31929                         SpriteSheetSize  [2]int16 // in sprites.
31930                         SpritePos        [2]int16 // in sprite sheet.
31931                         Visible          bool
31932                         MakeFootstepSnds bool
31933                         RotateSpeed      float32 // in radians per second.
31934                         Mesh             string
31935                         Colors           []color.NRGBA
31936                         CollideWithAOs   bool
31937                         StepHeight       float32
31938                         FaceRotateDir    bool
31939                         FaceRotateDirOff float32 // in degrees.
31940                         BackfaceCull     bool
31941                         Nametag          string
31942                         NametagColor     color.NRGBA
31943                         FaceRotateSpeed  float32 // in degrees per second.
31944                         Infotext         string
31945                         Itemstring       string
31946                         Glow             int8
31947                         MaxBreath        uint16  // Player only.
31948                         EyeHeight        float32 // Player only.
31949                         ZoomFOV          float32 // in degrees. Player only.
31950                         UseTextureAlpha  bool
31951                         DmgTextureMod    Texture // suffix
31952                         Shaded           bool
31953                         ShowOnMinimap    bool
31954                         NametagBG        color.NRGBA
31955                 }))(obj)).ZoomFOV
31956                 *p = math.Float32frombits(read32(r))
31957         }
31958         {
31959                 p := &(*(*(struct {
31960                         MaxHP            uint16 // Player only.
31961                         CollideWithNodes bool
31962                         Weight           float32 // deprecated
31963                         ColBox, SelBox   Box
31964                         Pointable        bool
31965                         Visual           string
31966                         VisualSize       [3]float32
31967                         Textures         []Texture
31968                         SpriteSheetSize  [2]int16 // in sprites.
31969                         SpritePos        [2]int16 // in sprite sheet.
31970                         Visible          bool
31971                         MakeFootstepSnds bool
31972                         RotateSpeed      float32 // in radians per second.
31973                         Mesh             string
31974                         Colors           []color.NRGBA
31975                         CollideWithAOs   bool
31976                         StepHeight       float32
31977                         FaceRotateDir    bool
31978                         FaceRotateDirOff float32 // in degrees.
31979                         BackfaceCull     bool
31980                         Nametag          string
31981                         NametagColor     color.NRGBA
31982                         FaceRotateSpeed  float32 // in degrees per second.
31983                         Infotext         string
31984                         Itemstring       string
31985                         Glow             int8
31986                         MaxBreath        uint16  // Player only.
31987                         EyeHeight        float32 // Player only.
31988                         ZoomFOV          float32 // in degrees. Player only.
31989                         UseTextureAlpha  bool
31990                         DmgTextureMod    Texture // suffix
31991                         Shaded           bool
31992                         ShowOnMinimap    bool
31993                         NametagBG        color.NRGBA
31994                 }))(obj)).UseTextureAlpha
31995                 switch n := read8(r); n {
31996                 case 0:
31997                         *p = false
31998                 case 1:
31999                         *p = true
32000                 default:
32001                         chk(fmt.Errorf("invalid bool: %d", n))
32002                 }
32003         }
32004         if err := pcall(func() {
32005                 ((*(*(struct {
32006                         MaxHP            uint16 // Player only.
32007                         CollideWithNodes bool
32008                         Weight           float32 // deprecated
32009                         ColBox, SelBox   Box
32010                         Pointable        bool
32011                         Visual           string
32012                         VisualSize       [3]float32
32013                         Textures         []Texture
32014                         SpriteSheetSize  [2]int16 // in sprites.
32015                         SpritePos        [2]int16 // in sprite sheet.
32016                         Visible          bool
32017                         MakeFootstepSnds bool
32018                         RotateSpeed      float32 // in radians per second.
32019                         Mesh             string
32020                         Colors           []color.NRGBA
32021                         CollideWithAOs   bool
32022                         StepHeight       float32
32023                         FaceRotateDir    bool
32024                         FaceRotateDirOff float32 // in degrees.
32025                         BackfaceCull     bool
32026                         Nametag          string
32027                         NametagColor     color.NRGBA
32028                         FaceRotateSpeed  float32 // in degrees per second.
32029                         Infotext         string
32030                         Itemstring       string
32031                         Glow             int8
32032                         MaxBreath        uint16  // Player only.
32033                         EyeHeight        float32 // Player only.
32034                         ZoomFOV          float32 // in degrees. Player only.
32035                         UseTextureAlpha  bool
32036                         DmgTextureMod    Texture // suffix
32037                         Shaded           bool
32038                         ShowOnMinimap    bool
32039                         NametagBG        color.NRGBA
32040                 }))(obj)).DmgTextureMod).deserialize(r)
32041         }); err != nil {
32042                 if err == io.EOF {
32043                         chk(io.EOF)
32044                 }
32045                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
32046         }
32047         {
32048                 p := &(*(*(struct {
32049                         MaxHP            uint16 // Player only.
32050                         CollideWithNodes bool
32051                         Weight           float32 // deprecated
32052                         ColBox, SelBox   Box
32053                         Pointable        bool
32054                         Visual           string
32055                         VisualSize       [3]float32
32056                         Textures         []Texture
32057                         SpriteSheetSize  [2]int16 // in sprites.
32058                         SpritePos        [2]int16 // in sprite sheet.
32059                         Visible          bool
32060                         MakeFootstepSnds bool
32061                         RotateSpeed      float32 // in radians per second.
32062                         Mesh             string
32063                         Colors           []color.NRGBA
32064                         CollideWithAOs   bool
32065                         StepHeight       float32
32066                         FaceRotateDir    bool
32067                         FaceRotateDirOff float32 // in degrees.
32068                         BackfaceCull     bool
32069                         Nametag          string
32070                         NametagColor     color.NRGBA
32071                         FaceRotateSpeed  float32 // in degrees per second.
32072                         Infotext         string
32073                         Itemstring       string
32074                         Glow             int8
32075                         MaxBreath        uint16  // Player only.
32076                         EyeHeight        float32 // Player only.
32077                         ZoomFOV          float32 // in degrees. Player only.
32078                         UseTextureAlpha  bool
32079                         DmgTextureMod    Texture // suffix
32080                         Shaded           bool
32081                         ShowOnMinimap    bool
32082                         NametagBG        color.NRGBA
32083                 }))(obj)).Shaded
32084                 switch n := read8(r); n {
32085                 case 0:
32086                         *p = false
32087                 case 1:
32088                         *p = true
32089                 default:
32090                         chk(fmt.Errorf("invalid bool: %d", n))
32091                 }
32092         }
32093         {
32094                 p := &(*(*(struct {
32095                         MaxHP            uint16 // Player only.
32096                         CollideWithNodes bool
32097                         Weight           float32 // deprecated
32098                         ColBox, SelBox   Box
32099                         Pointable        bool
32100                         Visual           string
32101                         VisualSize       [3]float32
32102                         Textures         []Texture
32103                         SpriteSheetSize  [2]int16 // in sprites.
32104                         SpritePos        [2]int16 // in sprite sheet.
32105                         Visible          bool
32106                         MakeFootstepSnds bool
32107                         RotateSpeed      float32 // in radians per second.
32108                         Mesh             string
32109                         Colors           []color.NRGBA
32110                         CollideWithAOs   bool
32111                         StepHeight       float32
32112                         FaceRotateDir    bool
32113                         FaceRotateDirOff float32 // in degrees.
32114                         BackfaceCull     bool
32115                         Nametag          string
32116                         NametagColor     color.NRGBA
32117                         FaceRotateSpeed  float32 // in degrees per second.
32118                         Infotext         string
32119                         Itemstring       string
32120                         Glow             int8
32121                         MaxBreath        uint16  // Player only.
32122                         EyeHeight        float32 // Player only.
32123                         ZoomFOV          float32 // in degrees. Player only.
32124                         UseTextureAlpha  bool
32125                         DmgTextureMod    Texture // suffix
32126                         Shaded           bool
32127                         ShowOnMinimap    bool
32128                         NametagBG        color.NRGBA
32129                 }))(obj)).ShowOnMinimap
32130                 switch n := read8(r); n {
32131                 case 0:
32132                         *p = false
32133                 case 1:
32134                         *p = true
32135                 default:
32136                         chk(fmt.Errorf("invalid bool: %d", n))
32137                 }
32138         }
32139         {
32140                 p := &(*(*(struct {
32141                         MaxHP            uint16 // Player only.
32142                         CollideWithNodes bool
32143                         Weight           float32 // deprecated
32144                         ColBox, SelBox   Box
32145                         Pointable        bool
32146                         Visual           string
32147                         VisualSize       [3]float32
32148                         Textures         []Texture
32149                         SpriteSheetSize  [2]int16 // in sprites.
32150                         SpritePos        [2]int16 // in sprite sheet.
32151                         Visible          bool
32152                         MakeFootstepSnds bool
32153                         RotateSpeed      float32 // in radians per second.
32154                         Mesh             string
32155                         Colors           []color.NRGBA
32156                         CollideWithAOs   bool
32157                         StepHeight       float32
32158                         FaceRotateDir    bool
32159                         FaceRotateDirOff float32 // in degrees.
32160                         BackfaceCull     bool
32161                         Nametag          string
32162                         NametagColor     color.NRGBA
32163                         FaceRotateSpeed  float32 // in degrees per second.
32164                         Infotext         string
32165                         Itemstring       string
32166                         Glow             int8
32167                         MaxBreath        uint16  // Player only.
32168                         EyeHeight        float32 // Player only.
32169                         ZoomFOV          float32 // in degrees. Player only.
32170                         UseTextureAlpha  bool
32171                         DmgTextureMod    Texture // suffix
32172                         Shaded           bool
32173                         ShowOnMinimap    bool
32174                         NametagBG        color.NRGBA
32175                 }))(obj)).NametagBG
32176                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
32177         }
32178 }
32179
32180 func (obj *AOPos) serialize(w io.Writer) {
32181         if err := pcall(func() {
32182                 ((*(*(struct {
32183                         Pos
32184                         Vel, Acc Vec
32185                         Rot      [3]float32
32186
32187                         Interpolate    bool
32188                         End            bool
32189                         UpdateInterval float32
32190                 }))(obj)).Pos).serialize(w)
32191         }); err != nil {
32192                 if err == io.EOF {
32193                         chk(io.EOF)
32194                 }
32195                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
32196         }
32197         if err := pcall(func() {
32198                 ((*(*(struct {
32199                         Pos
32200                         Vel, Acc Vec
32201                         Rot      [3]float32
32202
32203                         Interpolate    bool
32204                         End            bool
32205                         UpdateInterval float32
32206                 }))(obj)).Vel).serialize(w)
32207         }); err != nil {
32208                 if err == io.EOF {
32209                         chk(io.EOF)
32210                 }
32211                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32212         }
32213         if err := pcall(func() {
32214                 ((*(*(struct {
32215                         Pos
32216                         Vel, Acc Vec
32217                         Rot      [3]float32
32218
32219                         Interpolate    bool
32220                         End            bool
32221                         UpdateInterval float32
32222                 }))(obj)).Acc).serialize(w)
32223         }); err != nil {
32224                 if err == io.EOF {
32225                         chk(io.EOF)
32226                 }
32227                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32228         }
32229         for local355 := range (*(*(struct {
32230                 Pos
32231                 Vel, Acc Vec
32232                 Rot      [3]float32
32233
32234                 Interpolate    bool
32235                 End            bool
32236                 UpdateInterval float32
32237         }))(obj)).Rot {
32238                 {
32239                         x := ((*(*(struct {
32240                                 Pos
32241                                 Vel, Acc Vec
32242                                 Rot      [3]float32
32243
32244                                 Interpolate    bool
32245                                 End            bool
32246                                 UpdateInterval float32
32247                         }))(obj)).Rot)[local355]
32248                         write32(w, math.Float32bits(x))
32249                 }
32250         }
32251         {
32252                 x := (*(*(struct {
32253                         Pos
32254                         Vel, Acc Vec
32255                         Rot      [3]float32
32256
32257                         Interpolate    bool
32258                         End            bool
32259                         UpdateInterval float32
32260                 }))(obj)).Interpolate
32261                 if x {
32262                         write8(w, 1)
32263                 } else {
32264                         write8(w, 0)
32265                 }
32266         }
32267         {
32268                 x := (*(*(struct {
32269                         Pos
32270                         Vel, Acc Vec
32271                         Rot      [3]float32
32272
32273                         Interpolate    bool
32274                         End            bool
32275                         UpdateInterval float32
32276                 }))(obj)).End
32277                 if x {
32278                         write8(w, 1)
32279                 } else {
32280                         write8(w, 0)
32281                 }
32282         }
32283         {
32284                 x := (*(*(struct {
32285                         Pos
32286                         Vel, Acc Vec
32287                         Rot      [3]float32
32288
32289                         Interpolate    bool
32290                         End            bool
32291                         UpdateInterval float32
32292                 }))(obj)).UpdateInterval
32293                 write32(w, math.Float32bits(x))
32294         }
32295 }
32296
32297 func (obj *AOPos) deserialize(r io.Reader) {
32298         if err := pcall(func() {
32299                 ((*(*(struct {
32300                         Pos
32301                         Vel, Acc Vec
32302                         Rot      [3]float32
32303
32304                         Interpolate    bool
32305                         End            bool
32306                         UpdateInterval float32
32307                 }))(obj)).Pos).deserialize(r)
32308         }); err != nil {
32309                 if err == io.EOF {
32310                         chk(io.EOF)
32311                 }
32312                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
32313         }
32314         if err := pcall(func() {
32315                 ((*(*(struct {
32316                         Pos
32317                         Vel, Acc Vec
32318                         Rot      [3]float32
32319
32320                         Interpolate    bool
32321                         End            bool
32322                         UpdateInterval float32
32323                 }))(obj)).Vel).deserialize(r)
32324         }); err != nil {
32325                 if err == io.EOF {
32326                         chk(io.EOF)
32327                 }
32328                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32329         }
32330         if err := pcall(func() {
32331                 ((*(*(struct {
32332                         Pos
32333                         Vel, Acc Vec
32334                         Rot      [3]float32
32335
32336                         Interpolate    bool
32337                         End            bool
32338                         UpdateInterval float32
32339                 }))(obj)).Acc).deserialize(r)
32340         }); err != nil {
32341                 if err == io.EOF {
32342                         chk(io.EOF)
32343                 }
32344                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32345         }
32346         for local356 := range (*(*(struct {
32347                 Pos
32348                 Vel, Acc Vec
32349                 Rot      [3]float32
32350
32351                 Interpolate    bool
32352                 End            bool
32353                 UpdateInterval float32
32354         }))(obj)).Rot {
32355                 {
32356                         p := &((*(*(struct {
32357                                 Pos
32358                                 Vel, Acc Vec
32359                                 Rot      [3]float32
32360
32361                                 Interpolate    bool
32362                                 End            bool
32363                                 UpdateInterval float32
32364                         }))(obj)).Rot)[local356]
32365                         *p = math.Float32frombits(read32(r))
32366                 }
32367         }
32368         {
32369                 p := &(*(*(struct {
32370                         Pos
32371                         Vel, Acc Vec
32372                         Rot      [3]float32
32373
32374                         Interpolate    bool
32375                         End            bool
32376                         UpdateInterval float32
32377                 }))(obj)).Interpolate
32378                 switch n := read8(r); n {
32379                 case 0:
32380                         *p = false
32381                 case 1:
32382                         *p = true
32383                 default:
32384                         chk(fmt.Errorf("invalid bool: %d", n))
32385                 }
32386         }
32387         {
32388                 p := &(*(*(struct {
32389                         Pos
32390                         Vel, Acc Vec
32391                         Rot      [3]float32
32392
32393                         Interpolate    bool
32394                         End            bool
32395                         UpdateInterval float32
32396                 }))(obj)).End
32397                 switch n := read8(r); n {
32398                 case 0:
32399                         *p = false
32400                 case 1:
32401                         *p = true
32402                 default:
32403                         chk(fmt.Errorf("invalid bool: %d", n))
32404                 }
32405         }
32406         {
32407                 p := &(*(*(struct {
32408                         Pos
32409                         Vel, Acc Vec
32410                         Rot      [3]float32
32411
32412                         Interpolate    bool
32413                         End            bool
32414                         UpdateInterval float32
32415                 }))(obj)).UpdateInterval
32416                 *p = math.Float32frombits(read32(r))
32417         }
32418 }
32419
32420 func (obj *AOSprite) serialize(w io.Writer) {
32421         for local357 := range (*(*(struct {
32422                 Frame0          [2]int16
32423                 Frames          uint16
32424                 FrameDuration   float32
32425                 ViewAngleFrames bool
32426         }))(obj)).Frame0 {
32427                 {
32428                         x := ((*(*(struct {
32429                                 Frame0          [2]int16
32430                                 Frames          uint16
32431                                 FrameDuration   float32
32432                                 ViewAngleFrames bool
32433                         }))(obj)).Frame0)[local357]
32434                         write16(w, uint16(x))
32435                 }
32436         }
32437         {
32438                 x := (*(*(struct {
32439                         Frame0          [2]int16
32440                         Frames          uint16
32441                         FrameDuration   float32
32442                         ViewAngleFrames bool
32443                 }))(obj)).Frames
32444                 write16(w, uint16(x))
32445         }
32446         {
32447                 x := (*(*(struct {
32448                         Frame0          [2]int16
32449                         Frames          uint16
32450                         FrameDuration   float32
32451                         ViewAngleFrames bool
32452                 }))(obj)).FrameDuration
32453                 write32(w, math.Float32bits(x))
32454         }
32455         {
32456                 x := (*(*(struct {
32457                         Frame0          [2]int16
32458                         Frames          uint16
32459                         FrameDuration   float32
32460                         ViewAngleFrames bool
32461                 }))(obj)).ViewAngleFrames
32462                 if x {
32463                         write8(w, 1)
32464                 } else {
32465                         write8(w, 0)
32466                 }
32467         }
32468 }
32469
32470 func (obj *AOSprite) deserialize(r io.Reader) {
32471         for local358 := range (*(*(struct {
32472                 Frame0          [2]int16
32473                 Frames          uint16
32474                 FrameDuration   float32
32475                 ViewAngleFrames bool
32476         }))(obj)).Frame0 {
32477                 {
32478                         p := &((*(*(struct {
32479                                 Frame0          [2]int16
32480                                 Frames          uint16
32481                                 FrameDuration   float32
32482                                 ViewAngleFrames bool
32483                         }))(obj)).Frame0)[local358]
32484                         *p = int16(read16(r))
32485                 }
32486         }
32487         {
32488                 p := &(*(*(struct {
32489                         Frame0          [2]int16
32490                         Frames          uint16
32491                         FrameDuration   float32
32492                         ViewAngleFrames bool
32493                 }))(obj)).Frames
32494                 *p = read16(r)
32495         }
32496         {
32497                 p := &(*(*(struct {
32498                         Frame0          [2]int16
32499                         Frames          uint16
32500                         FrameDuration   float32
32501                         ViewAngleFrames bool
32502                 }))(obj)).FrameDuration
32503                 *p = math.Float32frombits(read32(r))
32504         }
32505         {
32506                 p := &(*(*(struct {
32507                         Frame0          [2]int16
32508                         Frames          uint16
32509                         FrameDuration   float32
32510                         ViewAngleFrames bool
32511                 }))(obj)).ViewAngleFrames
32512                 switch n := read8(r); n {
32513                 case 0:
32514                         *p = false
32515                 case 1:
32516                         *p = true
32517                 default:
32518                         chk(fmt.Errorf("invalid bool: %d", n))
32519                 }
32520         }
32521 }
32522
32523 func (obj *Group) serialize(w io.Writer) {
32524         if len(([]byte((*(*(struct {
32525                 Name   string
32526                 Rating int16
32527         }))(obj)).Name))) > math.MaxUint16 {
32528                 chk(ErrTooLong)
32529         }
32530         {
32531                 x := uint16(len(([]byte((*(*(struct {
32532                         Name   string
32533                         Rating int16
32534                 }))(obj)).Name))))
32535                 write16(w, uint16(x))
32536         }
32537         {
32538                 _, err := w.Write(([]byte((*(*(struct {
32539                         Name   string
32540                         Rating int16
32541                 }))(obj)).Name))[:])
32542                 chk(err)
32543         }
32544         {
32545                 x := (*(*(struct {
32546                         Name   string
32547                         Rating int16
32548                 }))(obj)).Rating
32549                 write16(w, uint16(x))
32550         }
32551 }
32552
32553 func (obj *Group) deserialize(r io.Reader) {
32554         var local359 []uint8
32555         var local360 uint16
32556         {
32557                 p := &local360
32558                 *p = read16(r)
32559         }
32560         (local359) = make([]uint8, local360)
32561         {
32562                 _, err := io.ReadFull(r, (local359)[:])
32563                 chk(err)
32564         }
32565         ((*(*(struct {
32566                 Name   string
32567                 Rating int16
32568         }))(obj)).Name) = string(local359)
32569         {
32570                 p := &(*(*(struct {
32571                         Name   string
32572                         Rating int16
32573                 }))(obj)).Rating
32574                 *p = int16(read16(r))
32575         }
32576 }
32577
32578 func (obj *AOAnim) serialize(w io.Writer) {
32579         for local361 := range (*(*(struct {
32580                 Frames [2]int32
32581                 Speed  float32
32582                 Blend  float32
32583                 NoLoop bool
32584         }))(obj)).Frames {
32585                 {
32586                         x := ((*(*(struct {
32587                                 Frames [2]int32
32588                                 Speed  float32
32589                                 Blend  float32
32590                                 NoLoop bool
32591                         }))(obj)).Frames)[local361]
32592                         write32(w, uint32(x))
32593                 }
32594         }
32595         {
32596                 x := (*(*(struct {
32597                         Frames [2]int32
32598                         Speed  float32
32599                         Blend  float32
32600                         NoLoop bool
32601                 }))(obj)).Speed
32602                 write32(w, math.Float32bits(x))
32603         }
32604         {
32605                 x := (*(*(struct {
32606                         Frames [2]int32
32607                         Speed  float32
32608                         Blend  float32
32609                         NoLoop bool
32610                 }))(obj)).Blend
32611                 write32(w, math.Float32bits(x))
32612         }
32613         {
32614                 x := (*(*(struct {
32615                         Frames [2]int32
32616                         Speed  float32
32617                         Blend  float32
32618                         NoLoop bool
32619                 }))(obj)).NoLoop
32620                 if x {
32621                         write8(w, 1)
32622                 } else {
32623                         write8(w, 0)
32624                 }
32625         }
32626 }
32627
32628 func (obj *AOAnim) deserialize(r io.Reader) {
32629         for local362 := range (*(*(struct {
32630                 Frames [2]int32
32631                 Speed  float32
32632                 Blend  float32
32633                 NoLoop bool
32634         }))(obj)).Frames {
32635                 {
32636                         p := &((*(*(struct {
32637                                 Frames [2]int32
32638                                 Speed  float32
32639                                 Blend  float32
32640                                 NoLoop bool
32641                         }))(obj)).Frames)[local362]
32642                         *p = int32(read32(r))
32643                 }
32644         }
32645         {
32646                 p := &(*(*(struct {
32647                         Frames [2]int32
32648                         Speed  float32
32649                         Blend  float32
32650                         NoLoop bool
32651                 }))(obj)).Speed
32652                 *p = math.Float32frombits(read32(r))
32653         }
32654         {
32655                 p := &(*(*(struct {
32656                         Frames [2]int32
32657                         Speed  float32
32658                         Blend  float32
32659                         NoLoop bool
32660                 }))(obj)).Blend
32661                 *p = math.Float32frombits(read32(r))
32662         }
32663         {
32664                 p := &(*(*(struct {
32665                         Frames [2]int32
32666                         Speed  float32
32667                         Blend  float32
32668                         NoLoop bool
32669                 }))(obj)).NoLoop
32670                 switch n := read8(r); n {
32671                 case 0:
32672                         *p = false
32673                 case 1:
32674                         *p = true
32675                 default:
32676                         chk(fmt.Errorf("invalid bool: %d", n))
32677                 }
32678         }
32679 }
32680
32681 func (obj *AOBonePos) serialize(w io.Writer) {
32682         if err := pcall(func() {
32683                 ((*(*(struct {
32684                         Pos Vec
32685                         Rot [3]float32
32686                 }))(obj)).Pos).serialize(w)
32687         }); err != nil {
32688                 if err == io.EOF {
32689                         chk(io.EOF)
32690                 }
32691                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32692         }
32693         for local363 := range (*(*(struct {
32694                 Pos Vec
32695                 Rot [3]float32
32696         }))(obj)).Rot {
32697                 {
32698                         x := ((*(*(struct {
32699                                 Pos Vec
32700                                 Rot [3]float32
32701                         }))(obj)).Rot)[local363]
32702                         write32(w, math.Float32bits(x))
32703                 }
32704         }
32705 }
32706
32707 func (obj *AOBonePos) deserialize(r io.Reader) {
32708         if err := pcall(func() {
32709                 ((*(*(struct {
32710                         Pos Vec
32711                         Rot [3]float32
32712                 }))(obj)).Pos).deserialize(r)
32713         }); err != nil {
32714                 if err == io.EOF {
32715                         chk(io.EOF)
32716                 }
32717                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32718         }
32719         for local364 := range (*(*(struct {
32720                 Pos Vec
32721                 Rot [3]float32
32722         }))(obj)).Rot {
32723                 {
32724                         p := &((*(*(struct {
32725                                 Pos Vec
32726                                 Rot [3]float32
32727                         }))(obj)).Rot)[local364]
32728                         *p = math.Float32frombits(read32(r))
32729                 }
32730         }
32731 }
32732
32733 func (obj *AOAttach) serialize(w io.Writer) {
32734         if err := pcall(func() {
32735                 ((*(*(struct {
32736                         ParentID     AOID
32737                         Bone         string
32738                         Pos          Vec
32739                         Rot          [3]float32
32740                         ForceVisible bool
32741                 }))(obj)).ParentID).serialize(w)
32742         }); err != nil {
32743                 if err == io.EOF {
32744                         chk(io.EOF)
32745                 }
32746                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
32747         }
32748         if len(([]byte((*(*(struct {
32749                 ParentID     AOID
32750                 Bone         string
32751                 Pos          Vec
32752                 Rot          [3]float32
32753                 ForceVisible bool
32754         }))(obj)).Bone))) > math.MaxUint16 {
32755                 chk(ErrTooLong)
32756         }
32757         {
32758                 x := uint16(len(([]byte((*(*(struct {
32759                         ParentID     AOID
32760                         Bone         string
32761                         Pos          Vec
32762                         Rot          [3]float32
32763                         ForceVisible bool
32764                 }))(obj)).Bone))))
32765                 write16(w, uint16(x))
32766         }
32767         {
32768                 _, err := w.Write(([]byte((*(*(struct {
32769                         ParentID     AOID
32770                         Bone         string
32771                         Pos          Vec
32772                         Rot          [3]float32
32773                         ForceVisible bool
32774                 }))(obj)).Bone))[:])
32775                 chk(err)
32776         }
32777         if err := pcall(func() {
32778                 ((*(*(struct {
32779                         ParentID     AOID
32780                         Bone         string
32781                         Pos          Vec
32782                         Rot          [3]float32
32783                         ForceVisible bool
32784                 }))(obj)).Pos).serialize(w)
32785         }); err != nil {
32786                 if err == io.EOF {
32787                         chk(io.EOF)
32788                 }
32789                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32790         }
32791         for local365 := range (*(*(struct {
32792                 ParentID     AOID
32793                 Bone         string
32794                 Pos          Vec
32795                 Rot          [3]float32
32796                 ForceVisible bool
32797         }))(obj)).Rot {
32798                 {
32799                         x := ((*(*(struct {
32800                                 ParentID     AOID
32801                                 Bone         string
32802                                 Pos          Vec
32803                                 Rot          [3]float32
32804                                 ForceVisible bool
32805                         }))(obj)).Rot)[local365]
32806                         write32(w, math.Float32bits(x))
32807                 }
32808         }
32809         {
32810                 x := (*(*(struct {
32811                         ParentID     AOID
32812                         Bone         string
32813                         Pos          Vec
32814                         Rot          [3]float32
32815                         ForceVisible bool
32816                 }))(obj)).ForceVisible
32817                 if x {
32818                         write8(w, 1)
32819                 } else {
32820                         write8(w, 0)
32821                 }
32822         }
32823 }
32824
32825 func (obj *AOAttach) deserialize(r io.Reader) {
32826         if err := pcall(func() {
32827                 ((*(*(struct {
32828                         ParentID     AOID
32829                         Bone         string
32830                         Pos          Vec
32831                         Rot          [3]float32
32832                         ForceVisible bool
32833                 }))(obj)).ParentID).deserialize(r)
32834         }); err != nil {
32835                 if err == io.EOF {
32836                         chk(io.EOF)
32837                 }
32838                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
32839         }
32840         var local366 []uint8
32841         var local367 uint16
32842         {
32843                 p := &local367
32844                 *p = read16(r)
32845         }
32846         (local366) = make([]uint8, local367)
32847         {
32848                 _, err := io.ReadFull(r, (local366)[:])
32849                 chk(err)
32850         }
32851         ((*(*(struct {
32852                 ParentID     AOID
32853                 Bone         string
32854                 Pos          Vec
32855                 Rot          [3]float32
32856                 ForceVisible bool
32857         }))(obj)).Bone) = string(local366)
32858         if err := pcall(func() {
32859                 ((*(*(struct {
32860                         ParentID     AOID
32861                         Bone         string
32862                         Pos          Vec
32863                         Rot          [3]float32
32864                         ForceVisible bool
32865                 }))(obj)).Pos).deserialize(r)
32866         }); err != nil {
32867                 if err == io.EOF {
32868                         chk(io.EOF)
32869                 }
32870                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32871         }
32872         for local368 := range (*(*(struct {
32873                 ParentID     AOID
32874                 Bone         string
32875                 Pos          Vec
32876                 Rot          [3]float32
32877                 ForceVisible bool
32878         }))(obj)).Rot {
32879                 {
32880                         p := &((*(*(struct {
32881                                 ParentID     AOID
32882                                 Bone         string
32883                                 Pos          Vec
32884                                 Rot          [3]float32
32885                                 ForceVisible bool
32886                         }))(obj)).Rot)[local368]
32887                         *p = math.Float32frombits(read32(r))
32888                 }
32889         }
32890         {
32891                 p := &(*(*(struct {
32892                         ParentID     AOID
32893                         Bone         string
32894                         Pos          Vec
32895                         Rot          [3]float32
32896                         ForceVisible bool
32897                 }))(obj)).ForceVisible
32898                 switch n := read8(r); n {
32899                 case 0:
32900                         *p = false
32901                 case 1:
32902                         *p = true
32903                 default:
32904                         chk(fmt.Errorf("invalid bool: %d", n))
32905                 }
32906         }
32907 }
32908
32909 func (obj *AOPhysOverride) serialize(w io.Writer) {
32910         {
32911                 x := (*(*(struct {
32912                         Walk, Jump, Gravity float32
32913
32914                         // Player only.
32915                         NoSneak, NoSneakGlitch, OldSneak bool
32916                 }))(obj)).Walk
32917                 write32(w, math.Float32bits(x))
32918         }
32919         {
32920                 x := (*(*(struct {
32921                         Walk, Jump, Gravity float32
32922
32923                         // Player only.
32924                         NoSneak, NoSneakGlitch, OldSneak bool
32925                 }))(obj)).Jump
32926                 write32(w, math.Float32bits(x))
32927         }
32928         {
32929                 x := (*(*(struct {
32930                         Walk, Jump, Gravity float32
32931
32932                         // Player only.
32933                         NoSneak, NoSneakGlitch, OldSneak bool
32934                 }))(obj)).Gravity
32935                 write32(w, math.Float32bits(x))
32936         }
32937         {
32938                 x := (*(*(struct {
32939                         Walk, Jump, Gravity float32
32940
32941                         // Player only.
32942                         NoSneak, NoSneakGlitch, OldSneak bool
32943                 }))(obj)).NoSneak
32944                 if x {
32945                         write8(w, 1)
32946                 } else {
32947                         write8(w, 0)
32948                 }
32949         }
32950         {
32951                 x := (*(*(struct {
32952                         Walk, Jump, Gravity float32
32953
32954                         // Player only.
32955                         NoSneak, NoSneakGlitch, OldSneak bool
32956                 }))(obj)).NoSneakGlitch
32957                 if x {
32958                         write8(w, 1)
32959                 } else {
32960                         write8(w, 0)
32961                 }
32962         }
32963         {
32964                 x := (*(*(struct {
32965                         Walk, Jump, Gravity float32
32966
32967                         // Player only.
32968                         NoSneak, NoSneakGlitch, OldSneak bool
32969                 }))(obj)).OldSneak
32970                 if x {
32971                         write8(w, 1)
32972                 } else {
32973                         write8(w, 0)
32974                 }
32975         }
32976 }
32977
32978 func (obj *AOPhysOverride) deserialize(r io.Reader) {
32979         {
32980                 p := &(*(*(struct {
32981                         Walk, Jump, Gravity float32
32982
32983                         // Player only.
32984                         NoSneak, NoSneakGlitch, OldSneak bool
32985                 }))(obj)).Walk
32986                 *p = math.Float32frombits(read32(r))
32987         }
32988         {
32989                 p := &(*(*(struct {
32990                         Walk, Jump, Gravity float32
32991
32992                         // Player only.
32993                         NoSneak, NoSneakGlitch, OldSneak bool
32994                 }))(obj)).Jump
32995                 *p = math.Float32frombits(read32(r))
32996         }
32997         {
32998                 p := &(*(*(struct {
32999                         Walk, Jump, Gravity float32
33000
33001                         // Player only.
33002                         NoSneak, NoSneakGlitch, OldSneak bool
33003                 }))(obj)).Gravity
33004                 *p = math.Float32frombits(read32(r))
33005         }
33006         {
33007                 p := &(*(*(struct {
33008                         Walk, Jump, Gravity float32
33009
33010                         // Player only.
33011                         NoSneak, NoSneakGlitch, OldSneak bool
33012                 }))(obj)).NoSneak
33013                 switch n := read8(r); n {
33014                 case 0:
33015                         *p = false
33016                 case 1:
33017                         *p = true
33018                 default:
33019                         chk(fmt.Errorf("invalid bool: %d", n))
33020                 }
33021         }
33022         {
33023                 p := &(*(*(struct {
33024                         Walk, Jump, Gravity float32
33025
33026                         // Player only.
33027                         NoSneak, NoSneakGlitch, OldSneak bool
33028                 }))(obj)).NoSneakGlitch
33029                 switch n := read8(r); n {
33030                 case 0:
33031                         *p = false
33032                 case 1:
33033                         *p = true
33034                 default:
33035                         chk(fmt.Errorf("invalid bool: %d", n))
33036                 }
33037         }
33038         {
33039                 p := &(*(*(struct {
33040                         Walk, Jump, Gravity float32
33041
33042                         // Player only.
33043                         NoSneak, NoSneakGlitch, OldSneak bool
33044                 }))(obj)).OldSneak
33045                 switch n := read8(r); n {
33046                 case 0:
33047                         *p = false
33048                 case 1:
33049                         *p = true
33050                 default:
33051                         chk(fmt.Errorf("invalid bool: %d", n))
33052                 }
33053         }
33054 }
33055
33056 func (obj *aoType) serialize(w io.Writer) {
33057         {
33058                 x := *(*(uint8))(obj)
33059                 write8(w, uint8(x))
33060         }
33061 }
33062
33063 func (obj *aoType) deserialize(r io.Reader) {
33064         {
33065                 p := &*(*(uint8))(obj)
33066                 *p = read8(r)
33067         }
33068 }
33069
33070 func (obj *NodeMetaField) serialize(w io.Writer) {
33071         if err := pcall(func() {
33072                 ((*(*(struct {
33073                         Field
33074                         Private bool
33075                 }))(obj)).Field).serialize(w)
33076         }); err != nil {
33077                 if err == io.EOF {
33078                         chk(io.EOF)
33079                 }
33080                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
33081         }
33082         {
33083                 x := (*(*(struct {
33084                         Field
33085                         Private bool
33086                 }))(obj)).Private
33087                 if x {
33088                         write8(w, 1)
33089                 } else {
33090                         write8(w, 0)
33091                 }
33092         }
33093 }
33094
33095 func (obj *NodeMetaField) deserialize(r io.Reader) {
33096         if err := pcall(func() {
33097                 ((*(*(struct {
33098                         Field
33099                         Private bool
33100                 }))(obj)).Field).deserialize(r)
33101         }); err != nil {
33102                 if err == io.EOF {
33103                         chk(io.EOF)
33104                 }
33105                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
33106         }
33107         {
33108                 p := &(*(*(struct {
33109                         Field
33110                         Private bool
33111                 }))(obj)).Private
33112                 switch n := read8(r); n {
33113                 case 0:
33114                         *p = false
33115                 case 1:
33116                         *p = true
33117                 default:
33118                         chk(fmt.Errorf("invalid bool: %d", n))
33119                 }
33120         }
33121 }
33122
33123 func (obj *MinimapType) serialize(w io.Writer) {
33124         {
33125                 x := *(*(uint16))(obj)
33126                 write16(w, uint16(x))
33127         }
33128 }
33129
33130 func (obj *MinimapType) deserialize(r io.Reader) {
33131         {
33132                 p := &*(*(uint16))(obj)
33133                 *p = read16(r)
33134         }
33135 }
33136
33137 func (obj *Param1Type) serialize(w io.Writer) {
33138         {
33139                 x := *(*(uint8))(obj)
33140                 write8(w, uint8(x))
33141         }
33142 }
33143
33144 func (obj *Param1Type) deserialize(r io.Reader) {
33145         {
33146                 p := &*(*(uint8))(obj)
33147                 *p = read8(r)
33148         }
33149 }
33150
33151 func (obj *Param2Type) serialize(w io.Writer) {
33152         {
33153                 x := *(*(uint8))(obj)
33154                 write8(w, uint8(x))
33155         }
33156 }
33157
33158 func (obj *Param2Type) deserialize(r io.Reader) {
33159         {
33160                 p := &*(*(uint8))(obj)
33161                 *p = read8(r)
33162         }
33163 }
33164
33165 func (obj *DrawType) serialize(w io.Writer) {
33166         {
33167                 x := *(*(uint8))(obj)
33168                 write8(w, uint8(x))
33169         }
33170 }
33171
33172 func (obj *DrawType) deserialize(r io.Reader) {
33173         {
33174                 p := &*(*(uint8))(obj)
33175                 *p = read8(r)
33176         }
33177 }
33178
33179 func (obj *TileDef) serialize(w io.Writer) {
33180         {
33181                 local369 := uint8(6)
33182                 {
33183                         x := local369
33184                         write8(w, uint8(x))
33185                 }
33186         }
33187         if err := pcall(func() {
33188                 ((*(*(struct {
33189                         Texture
33190                         Anim  TileAnim
33191                         Flags TileFlags
33192
33193                         //mt:if %s.Flags&TileColor != 0
33194                         R, G, B uint8
33195
33196                         //mt:if %s.Flags&TileScale != 0
33197                         Scale uint8
33198
33199                         //mt:if %s.Flags&TileAlign != 0
33200                         Align AlignType
33201                 }))(obj)).Texture).serialize(w)
33202         }); err != nil {
33203                 if err == io.EOF {
33204                         chk(io.EOF)
33205                 }
33206                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
33207         }
33208         if err := pcall(func() {
33209                 ((*(*(struct {
33210                         Texture
33211                         Anim  TileAnim
33212                         Flags TileFlags
33213
33214                         //mt:if %s.Flags&TileColor != 0
33215                         R, G, B uint8
33216
33217                         //mt:if %s.Flags&TileScale != 0
33218                         Scale uint8
33219
33220                         //mt:if %s.Flags&TileAlign != 0
33221                         Align AlignType
33222                 }))(obj)).Anim).serialize(w)
33223         }); err != nil {
33224                 if err == io.EOF {
33225                         chk(io.EOF)
33226                 }
33227                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
33228         }
33229         if err := pcall(func() {
33230                 ((*(*(struct {
33231                         Texture
33232                         Anim  TileAnim
33233                         Flags TileFlags
33234
33235                         //mt:if %s.Flags&TileColor != 0
33236                         R, G, B uint8
33237
33238                         //mt:if %s.Flags&TileScale != 0
33239                         Scale uint8
33240
33241                         //mt:if %s.Flags&TileAlign != 0
33242                         Align AlignType
33243                 }))(obj)).Flags).serialize(w)
33244         }); err != nil {
33245                 if err == io.EOF {
33246                         chk(io.EOF)
33247                 }
33248                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
33249         }
33250         if (*(*(struct {
33251                 Texture
33252                 Anim  TileAnim
33253                 Flags TileFlags
33254
33255                 //mt:if %s.Flags&TileColor != 0
33256                 R, G, B uint8
33257
33258                 //mt:if %s.Flags&TileScale != 0
33259                 Scale uint8
33260
33261                 //mt:if %s.Flags&TileAlign != 0
33262                 Align AlignType
33263         }))(obj)).Flags&TileColor != 0 {
33264                 {
33265                         x := (*(*(struct {
33266                                 Texture
33267                                 Anim  TileAnim
33268                                 Flags TileFlags
33269
33270                                 //mt:if %s.Flags&TileColor != 0
33271                                 R, G, B uint8
33272
33273                                 //mt:if %s.Flags&TileScale != 0
33274                                 Scale uint8
33275
33276                                 //mt:if %s.Flags&TileAlign != 0
33277                                 Align AlignType
33278                         }))(obj)).R
33279                         write8(w, uint8(x))
33280                 }
33281                 {
33282                         x := (*(*(struct {
33283                                 Texture
33284                                 Anim  TileAnim
33285                                 Flags TileFlags
33286
33287                                 //mt:if %s.Flags&TileColor != 0
33288                                 R, G, B uint8
33289
33290                                 //mt:if %s.Flags&TileScale != 0
33291                                 Scale uint8
33292
33293                                 //mt:if %s.Flags&TileAlign != 0
33294                                 Align AlignType
33295                         }))(obj)).G
33296                         write8(w, uint8(x))
33297                 }
33298                 {
33299                         x := (*(*(struct {
33300                                 Texture
33301                                 Anim  TileAnim
33302                                 Flags TileFlags
33303
33304                                 //mt:if %s.Flags&TileColor != 0
33305                                 R, G, B uint8
33306
33307                                 //mt:if %s.Flags&TileScale != 0
33308                                 Scale uint8
33309
33310                                 //mt:if %s.Flags&TileAlign != 0
33311                                 Align AlignType
33312                         }))(obj)).B
33313                         write8(w, uint8(x))
33314                 }
33315         }
33316         if (*(*(struct {
33317                 Texture
33318                 Anim  TileAnim
33319                 Flags TileFlags
33320
33321                 //mt:if %s.Flags&TileColor != 0
33322                 R, G, B uint8
33323
33324                 //mt:if %s.Flags&TileScale != 0
33325                 Scale uint8
33326
33327                 //mt:if %s.Flags&TileAlign != 0
33328                 Align AlignType
33329         }))(obj)).Flags&TileScale != 0 {
33330                 {
33331                         x := (*(*(struct {
33332                                 Texture
33333                                 Anim  TileAnim
33334                                 Flags TileFlags
33335
33336                                 //mt:if %s.Flags&TileColor != 0
33337                                 R, G, B uint8
33338
33339                                 //mt:if %s.Flags&TileScale != 0
33340                                 Scale uint8
33341
33342                                 //mt:if %s.Flags&TileAlign != 0
33343                                 Align AlignType
33344                         }))(obj)).Scale
33345                         write8(w, uint8(x))
33346                 }
33347         }
33348         if (*(*(struct {
33349                 Texture
33350                 Anim  TileAnim
33351                 Flags TileFlags
33352
33353                 //mt:if %s.Flags&TileColor != 0
33354                 R, G, B uint8
33355
33356                 //mt:if %s.Flags&TileScale != 0
33357                 Scale uint8
33358
33359                 //mt:if %s.Flags&TileAlign != 0
33360                 Align AlignType
33361         }))(obj)).Flags&TileAlign != 0 {
33362                 if err := pcall(func() {
33363                         ((*(*(struct {
33364                                 Texture
33365                                 Anim  TileAnim
33366                                 Flags TileFlags
33367
33368                                 //mt:if %s.Flags&TileColor != 0
33369                                 R, G, B uint8
33370
33371                                 //mt:if %s.Flags&TileScale != 0
33372                                 Scale uint8
33373
33374                                 //mt:if %s.Flags&TileAlign != 0
33375                                 Align AlignType
33376                         }))(obj)).Align).serialize(w)
33377                 }); err != nil {
33378                         if err == io.EOF {
33379                                 chk(io.EOF)
33380                         }
33381                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
33382                 }
33383         }
33384 }
33385
33386 func (obj *TileDef) deserialize(r io.Reader) {
33387         {
33388                 var local370 uint8
33389                 local371 := uint8(6)
33390                 {
33391                         p := &local370
33392                         *p = read8(r)
33393                 }
33394                 if local370 != local371 {
33395                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local370))
33396                 }
33397         }
33398         if err := pcall(func() {
33399                 ((*(*(struct {
33400                         Texture
33401                         Anim  TileAnim
33402                         Flags TileFlags
33403
33404                         //mt:if %s.Flags&TileColor != 0
33405                         R, G, B uint8
33406
33407                         //mt:if %s.Flags&TileScale != 0
33408                         Scale uint8
33409
33410                         //mt:if %s.Flags&TileAlign != 0
33411                         Align AlignType
33412                 }))(obj)).Texture).deserialize(r)
33413         }); err != nil {
33414                 if err == io.EOF {
33415                         chk(io.EOF)
33416                 }
33417                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
33418         }
33419         if err := pcall(func() {
33420                 ((*(*(struct {
33421                         Texture
33422                         Anim  TileAnim
33423                         Flags TileFlags
33424
33425                         //mt:if %s.Flags&TileColor != 0
33426                         R, G, B uint8
33427
33428                         //mt:if %s.Flags&TileScale != 0
33429                         Scale uint8
33430
33431                         //mt:if %s.Flags&TileAlign != 0
33432                         Align AlignType
33433                 }))(obj)).Anim).deserialize(r)
33434         }); err != nil {
33435                 if err == io.EOF {
33436                         chk(io.EOF)
33437                 }
33438                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
33439         }
33440         if err := pcall(func() {
33441                 ((*(*(struct {
33442                         Texture
33443                         Anim  TileAnim
33444                         Flags TileFlags
33445
33446                         //mt:if %s.Flags&TileColor != 0
33447                         R, G, B uint8
33448
33449                         //mt:if %s.Flags&TileScale != 0
33450                         Scale uint8
33451
33452                         //mt:if %s.Flags&TileAlign != 0
33453                         Align AlignType
33454                 }))(obj)).Flags).deserialize(r)
33455         }); err != nil {
33456                 if err == io.EOF {
33457                         chk(io.EOF)
33458                 }
33459                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
33460         }
33461         if (*(*(struct {
33462                 Texture
33463                 Anim  TileAnim
33464                 Flags TileFlags
33465
33466                 //mt:if %s.Flags&TileColor != 0
33467                 R, G, B uint8
33468
33469                 //mt:if %s.Flags&TileScale != 0
33470                 Scale uint8
33471
33472                 //mt:if %s.Flags&TileAlign != 0
33473                 Align AlignType
33474         }))(obj)).Flags&TileColor != 0 {
33475                 {
33476                         p := &(*(*(struct {
33477                                 Texture
33478                                 Anim  TileAnim
33479                                 Flags TileFlags
33480
33481                                 //mt:if %s.Flags&TileColor != 0
33482                                 R, G, B uint8
33483
33484                                 //mt:if %s.Flags&TileScale != 0
33485                                 Scale uint8
33486
33487                                 //mt:if %s.Flags&TileAlign != 0
33488                                 Align AlignType
33489                         }))(obj)).R
33490                         *p = read8(r)
33491                 }
33492                 {
33493                         p := &(*(*(struct {
33494                                 Texture
33495                                 Anim  TileAnim
33496                                 Flags TileFlags
33497
33498                                 //mt:if %s.Flags&TileColor != 0
33499                                 R, G, B uint8
33500
33501                                 //mt:if %s.Flags&TileScale != 0
33502                                 Scale uint8
33503
33504                                 //mt:if %s.Flags&TileAlign != 0
33505                                 Align AlignType
33506                         }))(obj)).G
33507                         *p = read8(r)
33508                 }
33509                 {
33510                         p := &(*(*(struct {
33511                                 Texture
33512                                 Anim  TileAnim
33513                                 Flags TileFlags
33514
33515                                 //mt:if %s.Flags&TileColor != 0
33516                                 R, G, B uint8
33517
33518                                 //mt:if %s.Flags&TileScale != 0
33519                                 Scale uint8
33520
33521                                 //mt:if %s.Flags&TileAlign != 0
33522                                 Align AlignType
33523                         }))(obj)).B
33524                         *p = read8(r)
33525                 }
33526         }
33527         if (*(*(struct {
33528                 Texture
33529                 Anim  TileAnim
33530                 Flags TileFlags
33531
33532                 //mt:if %s.Flags&TileColor != 0
33533                 R, G, B uint8
33534
33535                 //mt:if %s.Flags&TileScale != 0
33536                 Scale uint8
33537
33538                 //mt:if %s.Flags&TileAlign != 0
33539                 Align AlignType
33540         }))(obj)).Flags&TileScale != 0 {
33541                 {
33542                         p := &(*(*(struct {
33543                                 Texture
33544                                 Anim  TileAnim
33545                                 Flags TileFlags
33546
33547                                 //mt:if %s.Flags&TileColor != 0
33548                                 R, G, B uint8
33549
33550                                 //mt:if %s.Flags&TileScale != 0
33551                                 Scale uint8
33552
33553                                 //mt:if %s.Flags&TileAlign != 0
33554                                 Align AlignType
33555                         }))(obj)).Scale
33556                         *p = read8(r)
33557                 }
33558         }
33559         if (*(*(struct {
33560                 Texture
33561                 Anim  TileAnim
33562                 Flags TileFlags
33563
33564                 //mt:if %s.Flags&TileColor != 0
33565                 R, G, B uint8
33566
33567                 //mt:if %s.Flags&TileScale != 0
33568                 Scale uint8
33569
33570                 //mt:if %s.Flags&TileAlign != 0
33571                 Align AlignType
33572         }))(obj)).Flags&TileAlign != 0 {
33573                 if err := pcall(func() {
33574                         ((*(*(struct {
33575                                 Texture
33576                                 Anim  TileAnim
33577                                 Flags TileFlags
33578
33579                                 //mt:if %s.Flags&TileColor != 0
33580                                 R, G, B uint8
33581
33582                                 //mt:if %s.Flags&TileScale != 0
33583                                 Scale uint8
33584
33585                                 //mt:if %s.Flags&TileAlign != 0
33586                                 Align AlignType
33587                         }))(obj)).Align).deserialize(r)
33588                 }); err != nil {
33589                         if err == io.EOF {
33590                                 chk(io.EOF)
33591                         }
33592                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
33593                 }
33594         }
33595 }
33596
33597 func (obj *WaveType) serialize(w io.Writer) {
33598         {
33599                 x := *(*(uint8))(obj)
33600                 write8(w, uint8(x))
33601         }
33602 }
33603
33604 func (obj *WaveType) deserialize(r io.Reader) {
33605         {
33606                 p := &*(*(uint8))(obj)
33607                 *p = read8(r)
33608         }
33609 }
33610
33611 func (obj *LiquidType) serialize(w io.Writer) {
33612         {
33613                 x := *(*(uint8))(obj)
33614                 write8(w, uint8(x))
33615         }
33616 }
33617
33618 func (obj *LiquidType) deserialize(r io.Reader) {
33619         {
33620                 p := &*(*(uint8))(obj)
33621                 *p = read8(r)
33622         }
33623 }
33624
33625 func (obj *NodeBox) serialize(w io.Writer) {
33626         {
33627                 local372 := uint8(6)
33628                 {
33629                         x := local372
33630                         write8(w, uint8(x))
33631                 }
33632         }
33633         if err := pcall(func() {
33634                 ((*(*(struct {
33635                         Type NodeBoxType
33636
33637                         //mt:if %s.Type == MountedBox
33638                         WallTop, WallBot, WallSides Box
33639
33640                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33641                         Fixed []Box
33642
33643                         //mt:if %s.Type == ConnectedBox
33644                         ConnDirs, DiscoDirs  DirBoxes
33645                         DiscoAll, DiscoSides []Box
33646                 }))(obj)).Type).serialize(w)
33647         }); err != nil {
33648                 if err == io.EOF {
33649                         chk(io.EOF)
33650                 }
33651                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
33652         }
33653         if !((*(*(struct {
33654                 Type NodeBoxType
33655
33656                 //mt:if %s.Type == MountedBox
33657                 WallTop, WallBot, WallSides Box
33658
33659                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33660                 Fixed []Box
33661
33662                 //mt:if %s.Type == ConnectedBox
33663                 ConnDirs, DiscoDirs  DirBoxes
33664                 DiscoAll, DiscoSides []Box
33665         }))(obj)).Type < maxBox) {
33666                 chk(errors.New("assertion failed: %s.Type < maxBox"))
33667         }
33668         if (*(*(struct {
33669                 Type NodeBoxType
33670
33671                 //mt:if %s.Type == MountedBox
33672                 WallTop, WallBot, WallSides Box
33673
33674                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33675                 Fixed []Box
33676
33677                 //mt:if %s.Type == ConnectedBox
33678                 ConnDirs, DiscoDirs  DirBoxes
33679                 DiscoAll, DiscoSides []Box
33680         }))(obj)).Type == MountedBox {
33681                 if err := pcall(func() {
33682                         ((*(*(struct {
33683                                 Type NodeBoxType
33684
33685                                 //mt:if %s.Type == MountedBox
33686                                 WallTop, WallBot, WallSides Box
33687
33688                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33689                                 Fixed []Box
33690
33691                                 //mt:if %s.Type == ConnectedBox
33692                                 ConnDirs, DiscoDirs  DirBoxes
33693                                 DiscoAll, DiscoSides []Box
33694                         }))(obj)).WallTop).serialize(w)
33695                 }); err != nil {
33696                         if err == io.EOF {
33697                                 chk(io.EOF)
33698                         }
33699                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33700                 }
33701                 if err := pcall(func() {
33702                         ((*(*(struct {
33703                                 Type NodeBoxType
33704
33705                                 //mt:if %s.Type == MountedBox
33706                                 WallTop, WallBot, WallSides Box
33707
33708                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33709                                 Fixed []Box
33710
33711                                 //mt:if %s.Type == ConnectedBox
33712                                 ConnDirs, DiscoDirs  DirBoxes
33713                                 DiscoAll, DiscoSides []Box
33714                         }))(obj)).WallBot).serialize(w)
33715                 }); err != nil {
33716                         if err == io.EOF {
33717                                 chk(io.EOF)
33718                         }
33719                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33720                 }
33721                 if err := pcall(func() {
33722                         ((*(*(struct {
33723                                 Type NodeBoxType
33724
33725                                 //mt:if %s.Type == MountedBox
33726                                 WallTop, WallBot, WallSides Box
33727
33728                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33729                                 Fixed []Box
33730
33731                                 //mt:if %s.Type == ConnectedBox
33732                                 ConnDirs, DiscoDirs  DirBoxes
33733                                 DiscoAll, DiscoSides []Box
33734                         }))(obj)).WallSides).serialize(w)
33735                 }); err != nil {
33736                         if err == io.EOF {
33737                                 chk(io.EOF)
33738                         }
33739                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33740                 }
33741         }
33742         if t := (*(*(struct {
33743                 Type NodeBoxType
33744
33745                 //mt:if %s.Type == MountedBox
33746                 WallTop, WallBot, WallSides Box
33747
33748                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33749                 Fixed []Box
33750
33751                 //mt:if %s.Type == ConnectedBox
33752                 ConnDirs, DiscoDirs  DirBoxes
33753                 DiscoAll, DiscoSides []Box
33754         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
33755                 if len(((*(*(struct {
33756                         Type NodeBoxType
33757
33758                         //mt:if %s.Type == MountedBox
33759                         WallTop, WallBot, WallSides Box
33760
33761                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33762                         Fixed []Box
33763
33764                         //mt:if %s.Type == ConnectedBox
33765                         ConnDirs, DiscoDirs  DirBoxes
33766                         DiscoAll, DiscoSides []Box
33767                 }))(obj)).Fixed)) > math.MaxUint16 {
33768                         chk(ErrTooLong)
33769                 }
33770                 {
33771                         x := uint16(len(((*(*(struct {
33772                                 Type NodeBoxType
33773
33774                                 //mt:if %s.Type == MountedBox
33775                                 WallTop, WallBot, WallSides Box
33776
33777                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33778                                 Fixed []Box
33779
33780                                 //mt:if %s.Type == ConnectedBox
33781                                 ConnDirs, DiscoDirs  DirBoxes
33782                                 DiscoAll, DiscoSides []Box
33783                         }))(obj)).Fixed)))
33784                         write16(w, uint16(x))
33785                 }
33786                 for local373 := range (*(*(struct {
33787                         Type NodeBoxType
33788
33789                         //mt:if %s.Type == MountedBox
33790                         WallTop, WallBot, WallSides Box
33791
33792                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33793                         Fixed []Box
33794
33795                         //mt:if %s.Type == ConnectedBox
33796                         ConnDirs, DiscoDirs  DirBoxes
33797                         DiscoAll, DiscoSides []Box
33798                 }))(obj)).Fixed {
33799                         if err := pcall(func() {
33800                                 (((*(*(struct {
33801                                         Type NodeBoxType
33802
33803                                         //mt:if %s.Type == MountedBox
33804                                         WallTop, WallBot, WallSides Box
33805
33806                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33807                                         Fixed []Box
33808
33809                                         //mt:if %s.Type == ConnectedBox
33810                                         ConnDirs, DiscoDirs  DirBoxes
33811                                         DiscoAll, DiscoSides []Box
33812                                 }))(obj)).Fixed)[local373]).serialize(w)
33813                         }); err != nil {
33814                                 if err == io.EOF {
33815                                         chk(io.EOF)
33816                                 }
33817                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33818                         }
33819                 }
33820         }
33821         if (*(*(struct {
33822                 Type NodeBoxType
33823
33824                 //mt:if %s.Type == MountedBox
33825                 WallTop, WallBot, WallSides Box
33826
33827                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33828                 Fixed []Box
33829
33830                 //mt:if %s.Type == ConnectedBox
33831                 ConnDirs, DiscoDirs  DirBoxes
33832                 DiscoAll, DiscoSides []Box
33833         }))(obj)).Type == ConnectedBox {
33834                 if err := pcall(func() {
33835                         ((*(*(struct {
33836                                 Type NodeBoxType
33837
33838                                 //mt:if %s.Type == MountedBox
33839                                 WallTop, WallBot, WallSides Box
33840
33841                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33842                                 Fixed []Box
33843
33844                                 //mt:if %s.Type == ConnectedBox
33845                                 ConnDirs, DiscoDirs  DirBoxes
33846                                 DiscoAll, DiscoSides []Box
33847                         }))(obj)).ConnDirs).serialize(w)
33848                 }); err != nil {
33849                         if err == io.EOF {
33850                                 chk(io.EOF)
33851                         }
33852                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33853                 }
33854                 if err := pcall(func() {
33855                         ((*(*(struct {
33856                                 Type NodeBoxType
33857
33858                                 //mt:if %s.Type == MountedBox
33859                                 WallTop, WallBot, WallSides Box
33860
33861                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33862                                 Fixed []Box
33863
33864                                 //mt:if %s.Type == ConnectedBox
33865                                 ConnDirs, DiscoDirs  DirBoxes
33866                                 DiscoAll, DiscoSides []Box
33867                         }))(obj)).DiscoDirs).serialize(w)
33868                 }); err != nil {
33869                         if err == io.EOF {
33870                                 chk(io.EOF)
33871                         }
33872                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33873                 }
33874                 if len(((*(*(struct {
33875                         Type NodeBoxType
33876
33877                         //mt:if %s.Type == MountedBox
33878                         WallTop, WallBot, WallSides Box
33879
33880                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33881                         Fixed []Box
33882
33883                         //mt:if %s.Type == ConnectedBox
33884                         ConnDirs, DiscoDirs  DirBoxes
33885                         DiscoAll, DiscoSides []Box
33886                 }))(obj)).DiscoAll)) > math.MaxUint16 {
33887                         chk(ErrTooLong)
33888                 }
33889                 {
33890                         x := uint16(len(((*(*(struct {
33891                                 Type NodeBoxType
33892
33893                                 //mt:if %s.Type == MountedBox
33894                                 WallTop, WallBot, WallSides Box
33895
33896                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33897                                 Fixed []Box
33898
33899                                 //mt:if %s.Type == ConnectedBox
33900                                 ConnDirs, DiscoDirs  DirBoxes
33901                                 DiscoAll, DiscoSides []Box
33902                         }))(obj)).DiscoAll)))
33903                         write16(w, uint16(x))
33904                 }
33905                 for local374 := range (*(*(struct {
33906                         Type NodeBoxType
33907
33908                         //mt:if %s.Type == MountedBox
33909                         WallTop, WallBot, WallSides Box
33910
33911                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33912                         Fixed []Box
33913
33914                         //mt:if %s.Type == ConnectedBox
33915                         ConnDirs, DiscoDirs  DirBoxes
33916                         DiscoAll, DiscoSides []Box
33917                 }))(obj)).DiscoAll {
33918                         if err := pcall(func() {
33919                                 (((*(*(struct {
33920                                         Type NodeBoxType
33921
33922                                         //mt:if %s.Type == MountedBox
33923                                         WallTop, WallBot, WallSides Box
33924
33925                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33926                                         Fixed []Box
33927
33928                                         //mt:if %s.Type == ConnectedBox
33929                                         ConnDirs, DiscoDirs  DirBoxes
33930                                         DiscoAll, DiscoSides []Box
33931                                 }))(obj)).DiscoAll)[local374]).serialize(w)
33932                         }); err != nil {
33933                                 if err == io.EOF {
33934                                         chk(io.EOF)
33935                                 }
33936                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33937                         }
33938                 }
33939                 if len(((*(*(struct {
33940                         Type NodeBoxType
33941
33942                         //mt:if %s.Type == MountedBox
33943                         WallTop, WallBot, WallSides Box
33944
33945                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33946                         Fixed []Box
33947
33948                         //mt:if %s.Type == ConnectedBox
33949                         ConnDirs, DiscoDirs  DirBoxes
33950                         DiscoAll, DiscoSides []Box
33951                 }))(obj)).DiscoSides)) > math.MaxUint16 {
33952                         chk(ErrTooLong)
33953                 }
33954                 {
33955                         x := uint16(len(((*(*(struct {
33956                                 Type NodeBoxType
33957
33958                                 //mt:if %s.Type == MountedBox
33959                                 WallTop, WallBot, WallSides Box
33960
33961                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33962                                 Fixed []Box
33963
33964                                 //mt:if %s.Type == ConnectedBox
33965                                 ConnDirs, DiscoDirs  DirBoxes
33966                                 DiscoAll, DiscoSides []Box
33967                         }))(obj)).DiscoSides)))
33968                         write16(w, uint16(x))
33969                 }
33970                 for local375 := range (*(*(struct {
33971                         Type NodeBoxType
33972
33973                         //mt:if %s.Type == MountedBox
33974                         WallTop, WallBot, WallSides Box
33975
33976                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33977                         Fixed []Box
33978
33979                         //mt:if %s.Type == ConnectedBox
33980                         ConnDirs, DiscoDirs  DirBoxes
33981                         DiscoAll, DiscoSides []Box
33982                 }))(obj)).DiscoSides {
33983                         if err := pcall(func() {
33984                                 (((*(*(struct {
33985                                         Type NodeBoxType
33986
33987                                         //mt:if %s.Type == MountedBox
33988                                         WallTop, WallBot, WallSides Box
33989
33990                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33991                                         Fixed []Box
33992
33993                                         //mt:if %s.Type == ConnectedBox
33994                                         ConnDirs, DiscoDirs  DirBoxes
33995                                         DiscoAll, DiscoSides []Box
33996                                 }))(obj)).DiscoSides)[local375]).serialize(w)
33997                         }); err != nil {
33998                                 if err == io.EOF {
33999                                         chk(io.EOF)
34000                                 }
34001                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34002                         }
34003                 }
34004         }
34005 }
34006
34007 func (obj *NodeBox) deserialize(r io.Reader) {
34008         {
34009                 var local376 uint8
34010                 local377 := uint8(6)
34011                 {
34012                         p := &local376
34013                         *p = read8(r)
34014                 }
34015                 if local376 != local377 {
34016                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local376))
34017                 }
34018         }
34019         if err := pcall(func() {
34020                 ((*(*(struct {
34021                         Type NodeBoxType
34022
34023                         //mt:if %s.Type == MountedBox
34024                         WallTop, WallBot, WallSides Box
34025
34026                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34027                         Fixed []Box
34028
34029                         //mt:if %s.Type == ConnectedBox
34030                         ConnDirs, DiscoDirs  DirBoxes
34031                         DiscoAll, DiscoSides []Box
34032                 }))(obj)).Type).deserialize(r)
34033         }); err != nil {
34034                 if err == io.EOF {
34035                         chk(io.EOF)
34036                 }
34037                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
34038         }
34039         if !((*(*(struct {
34040                 Type NodeBoxType
34041
34042                 //mt:if %s.Type == MountedBox
34043                 WallTop, WallBot, WallSides Box
34044
34045                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34046                 Fixed []Box
34047
34048                 //mt:if %s.Type == ConnectedBox
34049                 ConnDirs, DiscoDirs  DirBoxes
34050                 DiscoAll, DiscoSides []Box
34051         }))(obj)).Type < maxBox) {
34052                 chk(errors.New("assertion failed: %s.Type < maxBox"))
34053         }
34054         if (*(*(struct {
34055                 Type NodeBoxType
34056
34057                 //mt:if %s.Type == MountedBox
34058                 WallTop, WallBot, WallSides Box
34059
34060                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34061                 Fixed []Box
34062
34063                 //mt:if %s.Type == ConnectedBox
34064                 ConnDirs, DiscoDirs  DirBoxes
34065                 DiscoAll, DiscoSides []Box
34066         }))(obj)).Type == MountedBox {
34067                 if err := pcall(func() {
34068                         ((*(*(struct {
34069                                 Type NodeBoxType
34070
34071                                 //mt:if %s.Type == MountedBox
34072                                 WallTop, WallBot, WallSides Box
34073
34074                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34075                                 Fixed []Box
34076
34077                                 //mt:if %s.Type == ConnectedBox
34078                                 ConnDirs, DiscoDirs  DirBoxes
34079                                 DiscoAll, DiscoSides []Box
34080                         }))(obj)).WallTop).deserialize(r)
34081                 }); err != nil {
34082                         if err == io.EOF {
34083                                 chk(io.EOF)
34084                         }
34085                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34086                 }
34087                 if err := pcall(func() {
34088                         ((*(*(struct {
34089                                 Type NodeBoxType
34090
34091                                 //mt:if %s.Type == MountedBox
34092                                 WallTop, WallBot, WallSides Box
34093
34094                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34095                                 Fixed []Box
34096
34097                                 //mt:if %s.Type == ConnectedBox
34098                                 ConnDirs, DiscoDirs  DirBoxes
34099                                 DiscoAll, DiscoSides []Box
34100                         }))(obj)).WallBot).deserialize(r)
34101                 }); err != nil {
34102                         if err == io.EOF {
34103                                 chk(io.EOF)
34104                         }
34105                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34106                 }
34107                 if err := pcall(func() {
34108                         ((*(*(struct {
34109                                 Type NodeBoxType
34110
34111                                 //mt:if %s.Type == MountedBox
34112                                 WallTop, WallBot, WallSides Box
34113
34114                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34115                                 Fixed []Box
34116
34117                                 //mt:if %s.Type == ConnectedBox
34118                                 ConnDirs, DiscoDirs  DirBoxes
34119                                 DiscoAll, DiscoSides []Box
34120                         }))(obj)).WallSides).deserialize(r)
34121                 }); err != nil {
34122                         if err == io.EOF {
34123                                 chk(io.EOF)
34124                         }
34125                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34126                 }
34127         }
34128         if t := (*(*(struct {
34129                 Type NodeBoxType
34130
34131                 //mt:if %s.Type == MountedBox
34132                 WallTop, WallBot, WallSides Box
34133
34134                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34135                 Fixed []Box
34136
34137                 //mt:if %s.Type == ConnectedBox
34138                 ConnDirs, DiscoDirs  DirBoxes
34139                 DiscoAll, DiscoSides []Box
34140         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
34141                 var local378 uint16
34142                 {
34143                         p := &local378
34144                         *p = read16(r)
34145                 }
34146                 ((*(*(struct {
34147                         Type NodeBoxType
34148
34149                         //mt:if %s.Type == MountedBox
34150                         WallTop, WallBot, WallSides Box
34151
34152                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34153                         Fixed []Box
34154
34155                         //mt:if %s.Type == ConnectedBox
34156                         ConnDirs, DiscoDirs  DirBoxes
34157                         DiscoAll, DiscoSides []Box
34158                 }))(obj)).Fixed) = make([]Box, local378)
34159                 for local379 := range (*(*(struct {
34160                         Type NodeBoxType
34161
34162                         //mt:if %s.Type == MountedBox
34163                         WallTop, WallBot, WallSides Box
34164
34165                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34166                         Fixed []Box
34167
34168                         //mt:if %s.Type == ConnectedBox
34169                         ConnDirs, DiscoDirs  DirBoxes
34170                         DiscoAll, DiscoSides []Box
34171                 }))(obj)).Fixed {
34172                         if err := pcall(func() {
34173                                 (((*(*(struct {
34174                                         Type NodeBoxType
34175
34176                                         //mt:if %s.Type == MountedBox
34177                                         WallTop, WallBot, WallSides Box
34178
34179                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34180                                         Fixed []Box
34181
34182                                         //mt:if %s.Type == ConnectedBox
34183                                         ConnDirs, DiscoDirs  DirBoxes
34184                                         DiscoAll, DiscoSides []Box
34185                                 }))(obj)).Fixed)[local379]).deserialize(r)
34186                         }); err != nil {
34187                                 if err == io.EOF {
34188                                         chk(io.EOF)
34189                                 }
34190                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34191                         }
34192                 }
34193         }
34194         if (*(*(struct {
34195                 Type NodeBoxType
34196
34197                 //mt:if %s.Type == MountedBox
34198                 WallTop, WallBot, WallSides Box
34199
34200                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34201                 Fixed []Box
34202
34203                 //mt:if %s.Type == ConnectedBox
34204                 ConnDirs, DiscoDirs  DirBoxes
34205                 DiscoAll, DiscoSides []Box
34206         }))(obj)).Type == ConnectedBox {
34207                 if err := pcall(func() {
34208                         ((*(*(struct {
34209                                 Type NodeBoxType
34210
34211                                 //mt:if %s.Type == MountedBox
34212                                 WallTop, WallBot, WallSides Box
34213
34214                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34215                                 Fixed []Box
34216
34217                                 //mt:if %s.Type == ConnectedBox
34218                                 ConnDirs, DiscoDirs  DirBoxes
34219                                 DiscoAll, DiscoSides []Box
34220                         }))(obj)).ConnDirs).deserialize(r)
34221                 }); err != nil {
34222                         if err == io.EOF {
34223                                 chk(io.EOF)
34224                         }
34225                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
34226                 }
34227                 if err := pcall(func() {
34228                         ((*(*(struct {
34229                                 Type NodeBoxType
34230
34231                                 //mt:if %s.Type == MountedBox
34232                                 WallTop, WallBot, WallSides Box
34233
34234                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34235                                 Fixed []Box
34236
34237                                 //mt:if %s.Type == ConnectedBox
34238                                 ConnDirs, DiscoDirs  DirBoxes
34239                                 DiscoAll, DiscoSides []Box
34240                         }))(obj)).DiscoDirs).deserialize(r)
34241                 }); err != nil {
34242                         if err == io.EOF {
34243                                 chk(io.EOF)
34244                         }
34245                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
34246                 }
34247                 var local380 uint16
34248                 {
34249                         p := &local380
34250                         *p = read16(r)
34251                 }
34252                 ((*(*(struct {
34253                         Type NodeBoxType
34254
34255                         //mt:if %s.Type == MountedBox
34256                         WallTop, WallBot, WallSides Box
34257
34258                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34259                         Fixed []Box
34260
34261                         //mt:if %s.Type == ConnectedBox
34262                         ConnDirs, DiscoDirs  DirBoxes
34263                         DiscoAll, DiscoSides []Box
34264                 }))(obj)).DiscoAll) = make([]Box, local380)
34265                 for local381 := range (*(*(struct {
34266                         Type NodeBoxType
34267
34268                         //mt:if %s.Type == MountedBox
34269                         WallTop, WallBot, WallSides Box
34270
34271                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34272                         Fixed []Box
34273
34274                         //mt:if %s.Type == ConnectedBox
34275                         ConnDirs, DiscoDirs  DirBoxes
34276                         DiscoAll, DiscoSides []Box
34277                 }))(obj)).DiscoAll {
34278                         if err := pcall(func() {
34279                                 (((*(*(struct {
34280                                         Type NodeBoxType
34281
34282                                         //mt:if %s.Type == MountedBox
34283                                         WallTop, WallBot, WallSides Box
34284
34285                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34286                                         Fixed []Box
34287
34288                                         //mt:if %s.Type == ConnectedBox
34289                                         ConnDirs, DiscoDirs  DirBoxes
34290                                         DiscoAll, DiscoSides []Box
34291                                 }))(obj)).DiscoAll)[local381]).deserialize(r)
34292                         }); err != nil {
34293                                 if err == io.EOF {
34294                                         chk(io.EOF)
34295                                 }
34296                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34297                         }
34298                 }
34299                 var local382 uint16
34300                 {
34301                         p := &local382
34302                         *p = read16(r)
34303                 }
34304                 ((*(*(struct {
34305                         Type NodeBoxType
34306
34307                         //mt:if %s.Type == MountedBox
34308                         WallTop, WallBot, WallSides Box
34309
34310                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34311                         Fixed []Box
34312
34313                         //mt:if %s.Type == ConnectedBox
34314                         ConnDirs, DiscoDirs  DirBoxes
34315                         DiscoAll, DiscoSides []Box
34316                 }))(obj)).DiscoSides) = make([]Box, local382)
34317                 for local383 := range (*(*(struct {
34318                         Type NodeBoxType
34319
34320                         //mt:if %s.Type == MountedBox
34321                         WallTop, WallBot, WallSides Box
34322
34323                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34324                         Fixed []Box
34325
34326                         //mt:if %s.Type == ConnectedBox
34327                         ConnDirs, DiscoDirs  DirBoxes
34328                         DiscoAll, DiscoSides []Box
34329                 }))(obj)).DiscoSides {
34330                         if err := pcall(func() {
34331                                 (((*(*(struct {
34332                                         Type NodeBoxType
34333
34334                                         //mt:if %s.Type == MountedBox
34335                                         WallTop, WallBot, WallSides Box
34336
34337                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34338                                         Fixed []Box
34339
34340                                         //mt:if %s.Type == ConnectedBox
34341                                         ConnDirs, DiscoDirs  DirBoxes
34342                                         DiscoAll, DiscoSides []Box
34343                                 }))(obj)).DiscoSides)[local383]).deserialize(r)
34344                         }); err != nil {
34345                                 if err == io.EOF {
34346                                         chk(io.EOF)
34347                                 }
34348                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34349                         }
34350                 }
34351         }
34352 }
34353
34354 func (obj *SoundDef) serialize(w io.Writer) {
34355         if len(([]byte((*(*(struct {
34356                 Name              string
34357                 Gain, Pitch, Fade float32
34358         }))(obj)).Name))) > math.MaxUint16 {
34359                 chk(ErrTooLong)
34360         }
34361         {
34362                 x := uint16(len(([]byte((*(*(struct {
34363                         Name              string
34364                         Gain, Pitch, Fade float32
34365                 }))(obj)).Name))))
34366                 write16(w, uint16(x))
34367         }
34368         {
34369                 _, err := w.Write(([]byte((*(*(struct {
34370                         Name              string
34371                         Gain, Pitch, Fade float32
34372                 }))(obj)).Name))[:])
34373                 chk(err)
34374         }
34375         {
34376                 x := (*(*(struct {
34377                         Name              string
34378                         Gain, Pitch, Fade float32
34379                 }))(obj)).Gain
34380                 write32(w, math.Float32bits(x))
34381         }
34382         {
34383                 x := (*(*(struct {
34384                         Name              string
34385                         Gain, Pitch, Fade float32
34386                 }))(obj)).Pitch
34387                 write32(w, math.Float32bits(x))
34388         }
34389         {
34390                 x := (*(*(struct {
34391                         Name              string
34392                         Gain, Pitch, Fade float32
34393                 }))(obj)).Fade
34394                 write32(w, math.Float32bits(x))
34395         }
34396 }
34397
34398 func (obj *SoundDef) deserialize(r io.Reader) {
34399         var local384 []uint8
34400         var local385 uint16
34401         {
34402                 p := &local385
34403                 *p = read16(r)
34404         }
34405         (local384) = make([]uint8, local385)
34406         {
34407                 _, err := io.ReadFull(r, (local384)[:])
34408                 chk(err)
34409         }
34410         ((*(*(struct {
34411                 Name              string
34412                 Gain, Pitch, Fade float32
34413         }))(obj)).Name) = string(local384)
34414         {
34415                 p := &(*(*(struct {
34416                         Name              string
34417                         Gain, Pitch, Fade float32
34418                 }))(obj)).Gain
34419                 *p = math.Float32frombits(read32(r))
34420         }
34421         {
34422                 p := &(*(*(struct {
34423                         Name              string
34424                         Gain, Pitch, Fade float32
34425                 }))(obj)).Pitch
34426                 *p = math.Float32frombits(read32(r))
34427         }
34428         {
34429                 p := &(*(*(struct {
34430                         Name              string
34431                         Gain, Pitch, Fade float32
34432                 }))(obj)).Fade
34433                 *p = math.Float32frombits(read32(r))
34434         }
34435 }
34436
34437 func (obj *AlphaUse) serialize(w io.Writer) {
34438         {
34439                 x := *(*(uint8))(obj)
34440                 write8(w, uint8(x))
34441         }
34442 }
34443
34444 func (obj *AlphaUse) deserialize(r io.Reader) {
34445         {
34446                 p := &*(*(uint8))(obj)
34447                 *p = read8(r)
34448         }
34449 }
34450
34451 func (obj *Keys) serialize(w io.Writer) {
34452         {
34453                 x := *(*(uint32))(obj)
34454                 write32(w, uint32(x))
34455         }
34456 }
34457
34458 func (obj *Keys) deserialize(r io.Reader) {
34459         {
34460                 p := &*(*(uint32))(obj)
34461                 *p = read32(r)
34462         }
34463 }
34464
34465 func (obj *MapBlkFlags) serialize(w io.Writer) {
34466         {
34467                 x := *(*(uint8))(obj)
34468                 write8(w, uint8(x))
34469         }
34470 }
34471
34472 func (obj *MapBlkFlags) deserialize(r io.Reader) {
34473         {
34474                 p := &*(*(uint8))(obj)
34475                 *p = read8(r)
34476         }
34477 }
34478
34479 func (obj *LitFromBlks) serialize(w io.Writer) {
34480         {
34481                 x := *(*(uint16))(obj)
34482                 write16(w, uint16(x))
34483         }
34484 }
34485
34486 func (obj *LitFromBlks) deserialize(r io.Reader) {
34487         {
34488                 p := &*(*(uint16))(obj)
34489                 *p = read16(r)
34490         }
34491 }
34492
34493 func (obj *AOInitData) serialize(w io.Writer) {
34494         {
34495                 local386 := uint8(1)
34496                 {
34497                         x := local386
34498                         write8(w, uint8(x))
34499                 }
34500         }
34501         if len(([]byte((*(*(struct {
34502
34503                 // For players.
34504                 Name     string
34505                 IsPlayer bool
34506
34507                 ID AOID
34508
34509                 Pos
34510                 Rot [3]float32
34511
34512                 HP uint16
34513
34514                 // See (de)serialize.fmt.
34515                 Msgs []AOMsg
34516         }))(obj)).Name))) > math.MaxUint16 {
34517                 chk(ErrTooLong)
34518         }
34519         {
34520                 x := uint16(len(([]byte((*(*(struct {
34521
34522                         // For players.
34523                         Name     string
34524                         IsPlayer bool
34525
34526                         ID AOID
34527
34528                         Pos
34529                         Rot [3]float32
34530
34531                         HP uint16
34532
34533                         // See (de)serialize.fmt.
34534                         Msgs []AOMsg
34535                 }))(obj)).Name))))
34536                 write16(w, uint16(x))
34537         }
34538         {
34539                 _, err := w.Write(([]byte((*(*(struct {
34540
34541                         // For players.
34542                         Name     string
34543                         IsPlayer bool
34544
34545                         ID AOID
34546
34547                         Pos
34548                         Rot [3]float32
34549
34550                         HP uint16
34551
34552                         // See (de)serialize.fmt.
34553                         Msgs []AOMsg
34554                 }))(obj)).Name))[:])
34555                 chk(err)
34556         }
34557         {
34558                 x := (*(*(struct {
34559
34560                         // For players.
34561                         Name     string
34562                         IsPlayer bool
34563
34564                         ID AOID
34565
34566                         Pos
34567                         Rot [3]float32
34568
34569                         HP uint16
34570
34571                         // See (de)serialize.fmt.
34572                         Msgs []AOMsg
34573                 }))(obj)).IsPlayer
34574                 if x {
34575                         write8(w, 1)
34576                 } else {
34577                         write8(w, 0)
34578                 }
34579         }
34580         if err := pcall(func() {
34581                 ((*(*(struct {
34582
34583                         // For players.
34584                         Name     string
34585                         IsPlayer bool
34586
34587                         ID AOID
34588
34589                         Pos
34590                         Rot [3]float32
34591
34592                         HP uint16
34593
34594                         // See (de)serialize.fmt.
34595                         Msgs []AOMsg
34596                 }))(obj)).ID).serialize(w)
34597         }); err != nil {
34598                 if err == io.EOF {
34599                         chk(io.EOF)
34600                 }
34601                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
34602         }
34603         if err := pcall(func() {
34604                 ((*(*(struct {
34605
34606                         // For players.
34607                         Name     string
34608                         IsPlayer bool
34609
34610                         ID AOID
34611
34612                         Pos
34613                         Rot [3]float32
34614
34615                         HP uint16
34616
34617                         // See (de)serialize.fmt.
34618                         Msgs []AOMsg
34619                 }))(obj)).Pos).serialize(w)
34620         }); err != nil {
34621                 if err == io.EOF {
34622                         chk(io.EOF)
34623                 }
34624                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
34625         }
34626         for local387 := range (*(*(struct {
34627
34628                 // For players.
34629                 Name     string
34630                 IsPlayer bool
34631
34632                 ID AOID
34633
34634                 Pos
34635                 Rot [3]float32
34636
34637                 HP uint16
34638
34639                 // See (de)serialize.fmt.
34640                 Msgs []AOMsg
34641         }))(obj)).Rot {
34642                 {
34643                         x := ((*(*(struct {
34644
34645                                 // For players.
34646                                 Name     string
34647                                 IsPlayer bool
34648
34649                                 ID AOID
34650
34651                                 Pos
34652                                 Rot [3]float32
34653
34654                                 HP uint16
34655
34656                                 // See (de)serialize.fmt.
34657                                 Msgs []AOMsg
34658                         }))(obj)).Rot)[local387]
34659                         write32(w, math.Float32bits(x))
34660                 }
34661         }
34662         {
34663                 x := (*(*(struct {
34664
34665                         // For players.
34666                         Name     string
34667                         IsPlayer bool
34668
34669                         ID AOID
34670
34671                         Pos
34672                         Rot [3]float32
34673
34674                         HP uint16
34675
34676                         // See (de)serialize.fmt.
34677                         Msgs []AOMsg
34678                 }))(obj)).HP
34679                 write16(w, uint16(x))
34680         }
34681         {
34682                 x := (*(*(struct {
34683
34684                         // For players.
34685                         Name     string
34686                         IsPlayer bool
34687
34688                         ID AOID
34689
34690                         Pos
34691                         Rot [3]float32
34692
34693                         HP uint16
34694
34695                         // See (de)serialize.fmt.
34696                         Msgs []AOMsg
34697                 }))(obj)).Msgs
34698                 { // For AOInitData.Msgs.
34699                         if len(x) > math.MaxUint8 {
34700                                 chk(ErrTooLong)
34701                         }
34702                         write8(w, uint8(len(x)))
34703                         for _, msg := range x {
34704                                 var b bytes.Buffer
34705                                 chk(writeAOMsg(&b, msg))
34706                                 if b.Len() > math.MaxUint32 {
34707                                         chk(ErrTooLong)
34708                                 }
34709                                 write32(w, uint32(b.Len()))
34710                                 _, err := b.WriteTo(w)
34711                                 chk(err)
34712                         }
34713                 }
34714         }
34715 }
34716
34717 func (obj *AOInitData) deserialize(r io.Reader) {
34718         {
34719                 var local388 uint8
34720                 local389 := uint8(1)
34721                 {
34722                         p := &local388
34723                         *p = read8(r)
34724                 }
34725                 if local388 != local389 {
34726                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local388))
34727                 }
34728         }
34729         var local390 []uint8
34730         var local391 uint16
34731         {
34732                 p := &local391
34733                 *p = read16(r)
34734         }
34735         (local390) = make([]uint8, local391)
34736         {
34737                 _, err := io.ReadFull(r, (local390)[:])
34738                 chk(err)
34739         }
34740         ((*(*(struct {
34741
34742                 // For players.
34743                 Name     string
34744                 IsPlayer bool
34745
34746                 ID AOID
34747
34748                 Pos
34749                 Rot [3]float32
34750
34751                 HP uint16
34752
34753                 // See (de)serialize.fmt.
34754                 Msgs []AOMsg
34755         }))(obj)).Name) = string(local390)
34756         {
34757                 p := &(*(*(struct {
34758
34759                         // For players.
34760                         Name     string
34761                         IsPlayer bool
34762
34763                         ID AOID
34764
34765                         Pos
34766                         Rot [3]float32
34767
34768                         HP uint16
34769
34770                         // See (de)serialize.fmt.
34771                         Msgs []AOMsg
34772                 }))(obj)).IsPlayer
34773                 switch n := read8(r); n {
34774                 case 0:
34775                         *p = false
34776                 case 1:
34777                         *p = true
34778                 default:
34779                         chk(fmt.Errorf("invalid bool: %d", n))
34780                 }
34781         }
34782         if err := pcall(func() {
34783                 ((*(*(struct {
34784
34785                         // For players.
34786                         Name     string
34787                         IsPlayer bool
34788
34789                         ID AOID
34790
34791                         Pos
34792                         Rot [3]float32
34793
34794                         HP uint16
34795
34796                         // See (de)serialize.fmt.
34797                         Msgs []AOMsg
34798                 }))(obj)).ID).deserialize(r)
34799         }); err != nil {
34800                 if err == io.EOF {
34801                         chk(io.EOF)
34802                 }
34803                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
34804         }
34805         if err := pcall(func() {
34806                 ((*(*(struct {
34807
34808                         // For players.
34809                         Name     string
34810                         IsPlayer bool
34811
34812                         ID AOID
34813
34814                         Pos
34815                         Rot [3]float32
34816
34817                         HP uint16
34818
34819                         // See (de)serialize.fmt.
34820                         Msgs []AOMsg
34821                 }))(obj)).Pos).deserialize(r)
34822         }); err != nil {
34823                 if err == io.EOF {
34824                         chk(io.EOF)
34825                 }
34826                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
34827         }
34828         for local392 := range (*(*(struct {
34829
34830                 // For players.
34831                 Name     string
34832                 IsPlayer bool
34833
34834                 ID AOID
34835
34836                 Pos
34837                 Rot [3]float32
34838
34839                 HP uint16
34840
34841                 // See (de)serialize.fmt.
34842                 Msgs []AOMsg
34843         }))(obj)).Rot {
34844                 {
34845                         p := &((*(*(struct {
34846
34847                                 // For players.
34848                                 Name     string
34849                                 IsPlayer bool
34850
34851                                 ID AOID
34852
34853                                 Pos
34854                                 Rot [3]float32
34855
34856                                 HP uint16
34857
34858                                 // See (de)serialize.fmt.
34859                                 Msgs []AOMsg
34860                         }))(obj)).Rot)[local392]
34861                         *p = math.Float32frombits(read32(r))
34862                 }
34863         }
34864         {
34865                 p := &(*(*(struct {
34866
34867                         // For players.
34868                         Name     string
34869                         IsPlayer bool
34870
34871                         ID AOID
34872
34873                         Pos
34874                         Rot [3]float32
34875
34876                         HP uint16
34877
34878                         // See (de)serialize.fmt.
34879                         Msgs []AOMsg
34880                 }))(obj)).HP
34881                 *p = read16(r)
34882         }
34883         {
34884                 p := &(*(*(struct {
34885
34886                         // For players.
34887                         Name     string
34888                         IsPlayer bool
34889
34890                         ID AOID
34891
34892                         Pos
34893                         Rot [3]float32
34894
34895                         HP uint16
34896
34897                         // See (de)serialize.fmt.
34898                         Msgs []AOMsg
34899                 }))(obj)).Msgs
34900                 { // For AOInitData.Msgs.
34901                         *p = make([]AOMsg, read8(r))
34902                         for i := range *p {
34903                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
34904                                 msg, err := readAOMsg(r)
34905                                 chk(err)
34906                                 (*p)[i] = msg
34907                                 if r.N > 0 {
34908                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34909                                 }
34910                         }
34911                 }
34912         }
34913 }
34914
34915 func (obj *ItemType) serialize(w io.Writer) {
34916         {
34917                 x := *(*(uint8))(obj)
34918                 write8(w, uint8(x))
34919         }
34920 }
34921
34922 func (obj *ItemType) deserialize(r io.Reader) {
34923         {
34924                 p := &*(*(uint8))(obj)
34925                 *p = read8(r)
34926         }
34927 }
34928
34929 func (obj *ToolCaps) serialize(w io.Writer) {
34930         if _ = (*(*(struct {
34931                 //mt:if _ = %s; false
34932                 NonNil bool
34933
34934                 AttackCooldown float32
34935                 MaxDropLvl     int16
34936
34937                 //mt:len32
34938                 GroupCaps []ToolGroupCap
34939
34940                 //mt:len32
34941                 DmgGroups []Group
34942
34943                 //mt:32tou16
34944                 PunchUses int32
34945         }))(obj)); false {
34946                 {
34947                         x := (*(*(struct {
34948                                 //mt:if _ = %s; false
34949                                 NonNil bool
34950
34951                                 AttackCooldown float32
34952                                 MaxDropLvl     int16
34953
34954                                 //mt:len32
34955                                 GroupCaps []ToolGroupCap
34956
34957                                 //mt:len32
34958                                 DmgGroups []Group
34959
34960                                 //mt:32tou16
34961                                 PunchUses int32
34962                         }))(obj)).NonNil
34963                         if x {
34964                                 write8(w, 1)
34965                         } else {
34966                                 write8(w, 0)
34967                         }
34968                 }
34969         }
34970         {
34971                 ow := w
34972                 w := new(bytes.Buffer)
34973                 /*
34974                    if r.N > 0 { (*(*(struct {
34975                         //mt:if _ = %s; false
34976                         NonNil  bool
34977
34978                         AttackCooldown  float32
34979                         MaxDropLvl      int16
34980
34981                         //mt:len32
34982                         GroupCaps       []ToolGroupCap
34983
34984                         //mt:len32
34985                         DmgGroups       []Group
34986
34987                         //mt:32tou16
34988                         PunchUses       int32
34989                    }))(obj)).NonNil = true}; /**/{
34990                         if (*(*(struct {
34991                                 //mt:if _ = %s; false
34992                                 NonNil bool
34993
34994                                 AttackCooldown float32
34995                                 MaxDropLvl     int16
34996
34997                                 //mt:len32
34998                                 GroupCaps []ToolGroupCap
34999
35000                                 //mt:len32
35001                                 DmgGroups []Group
35002
35003                                 //mt:32tou16
35004                                 PunchUses int32
35005                         }))(obj)).NonNil {
35006                                 {
35007                                         local393 := uint8(5)
35008                                         {
35009                                                 x := local393
35010                                                 write8(w, uint8(x))
35011                                         }
35012                                 }
35013                                 {
35014                                         x := (*(*(struct {
35015                                                 //mt:if _ = %s; false
35016                                                 NonNil bool
35017
35018                                                 AttackCooldown float32
35019                                                 MaxDropLvl     int16
35020
35021                                                 //mt:len32
35022                                                 GroupCaps []ToolGroupCap
35023
35024                                                 //mt:len32
35025                                                 DmgGroups []Group
35026
35027                                                 //mt:32tou16
35028                                                 PunchUses int32
35029                                         }))(obj)).AttackCooldown
35030                                         write32(w, math.Float32bits(x))
35031                                 }
35032                                 {
35033                                         x := (*(*(struct {
35034                                                 //mt:if _ = %s; false
35035                                                 NonNil bool
35036
35037                                                 AttackCooldown float32
35038                                                 MaxDropLvl     int16
35039
35040                                                 //mt:len32
35041                                                 GroupCaps []ToolGroupCap
35042
35043                                                 //mt:len32
35044                                                 DmgGroups []Group
35045
35046                                                 //mt:32tou16
35047                                                 PunchUses int32
35048                                         }))(obj)).MaxDropLvl
35049                                         write16(w, uint16(x))
35050                                 }
35051                                 if len(((*(*(struct {
35052                                         //mt:if _ = %s; false
35053                                         NonNil bool
35054
35055                                         AttackCooldown float32
35056                                         MaxDropLvl     int16
35057
35058                                         //mt:len32
35059                                         GroupCaps []ToolGroupCap
35060
35061                                         //mt:len32
35062                                         DmgGroups []Group
35063
35064                                         //mt:32tou16
35065                                         PunchUses int32
35066                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
35067                                         chk(ErrTooLong)
35068                                 }
35069                                 {
35070                                         x := uint32(len(((*(*(struct {
35071                                                 //mt:if _ = %s; false
35072                                                 NonNil bool
35073
35074                                                 AttackCooldown float32
35075                                                 MaxDropLvl     int16
35076
35077                                                 //mt:len32
35078                                                 GroupCaps []ToolGroupCap
35079
35080                                                 //mt:len32
35081                                                 DmgGroups []Group
35082
35083                                                 //mt:32tou16
35084                                                 PunchUses int32
35085                                         }))(obj)).GroupCaps)))
35086                                         write32(w, uint32(x))
35087                                 }
35088                                 for local394 := range (*(*(struct {
35089                                         //mt:if _ = %s; false
35090                                         NonNil bool
35091
35092                                         AttackCooldown float32
35093                                         MaxDropLvl     int16
35094
35095                                         //mt:len32
35096                                         GroupCaps []ToolGroupCap
35097
35098                                         //mt:len32
35099                                         DmgGroups []Group
35100
35101                                         //mt:32tou16
35102                                         PunchUses int32
35103                                 }))(obj)).GroupCaps {
35104                                         if err := pcall(func() {
35105                                                 (((*(*(struct {
35106                                                         //mt:if _ = %s; false
35107                                                         NonNil bool
35108
35109                                                         AttackCooldown float32
35110                                                         MaxDropLvl     int16
35111
35112                                                         //mt:len32
35113                                                         GroupCaps []ToolGroupCap
35114
35115                                                         //mt:len32
35116                                                         DmgGroups []Group
35117
35118                                                         //mt:32tou16
35119                                                         PunchUses int32
35120                                                 }))(obj)).GroupCaps)[local394]).serialize(w)
35121                                         }); err != nil {
35122                                                 if err == io.EOF {
35123                                                         chk(io.EOF)
35124                                                 }
35125                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
35126                                         }
35127                                 }
35128                                 if len(((*(*(struct {
35129                                         //mt:if _ = %s; false
35130                                         NonNil bool
35131
35132                                         AttackCooldown float32
35133                                         MaxDropLvl     int16
35134
35135                                         //mt:len32
35136                                         GroupCaps []ToolGroupCap
35137
35138                                         //mt:len32
35139                                         DmgGroups []Group
35140
35141                                         //mt:32tou16
35142                                         PunchUses int32
35143                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
35144                                         chk(ErrTooLong)
35145                                 }
35146                                 {
35147                                         x := uint32(len(((*(*(struct {
35148                                                 //mt:if _ = %s; false
35149                                                 NonNil bool
35150
35151                                                 AttackCooldown float32
35152                                                 MaxDropLvl     int16
35153
35154                                                 //mt:len32
35155                                                 GroupCaps []ToolGroupCap
35156
35157                                                 //mt:len32
35158                                                 DmgGroups []Group
35159
35160                                                 //mt:32tou16
35161                                                 PunchUses int32
35162                                         }))(obj)).DmgGroups)))
35163                                         write32(w, uint32(x))
35164                                 }
35165                                 for local395 := range (*(*(struct {
35166                                         //mt:if _ = %s; false
35167                                         NonNil bool
35168
35169                                         AttackCooldown float32
35170                                         MaxDropLvl     int16
35171
35172                                         //mt:len32
35173                                         GroupCaps []ToolGroupCap
35174
35175                                         //mt:len32
35176                                         DmgGroups []Group
35177
35178                                         //mt:32tou16
35179                                         PunchUses int32
35180                                 }))(obj)).DmgGroups {
35181                                         if err := pcall(func() {
35182                                                 (((*(*(struct {
35183                                                         //mt:if _ = %s; false
35184                                                         NonNil bool
35185
35186                                                         AttackCooldown float32
35187                                                         MaxDropLvl     int16
35188
35189                                                         //mt:len32
35190                                                         GroupCaps []ToolGroupCap
35191
35192                                                         //mt:len32
35193                                                         DmgGroups []Group
35194
35195                                                         //mt:32tou16
35196                                                         PunchUses int32
35197                                                 }))(obj)).DmgGroups)[local395]).serialize(w)
35198                                         }); err != nil {
35199                                                 if err == io.EOF {
35200                                                         chk(io.EOF)
35201                                                 }
35202                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
35203                                         }
35204                                 }
35205                                 {
35206                                         x := uint16((*(*(struct {
35207                                                 //mt:if _ = %s; false
35208                                                 NonNil bool
35209
35210                                                 AttackCooldown float32
35211                                                 MaxDropLvl     int16
35212
35213                                                 //mt:len32
35214                                                 GroupCaps []ToolGroupCap
35215
35216                                                 //mt:len32
35217                                                 DmgGroups []Group
35218
35219                                                 //mt:32tou16
35220                                                 PunchUses int32
35221                                         }))(obj)).PunchUses)
35222                                         write16(w, uint16(x))
35223                                 }
35224                         }
35225                 }
35226                 {
35227                         buf := w
35228                         w := ow
35229                         if len((buf.Bytes())) > math.MaxUint16 {
35230                                 chk(ErrTooLong)
35231                         }
35232                         {
35233                                 x := uint16(len((buf.Bytes())))
35234                                 write16(w, uint16(x))
35235                         }
35236                         {
35237                                 _, err := w.Write((buf.Bytes())[:])
35238                                 chk(err)
35239                         }
35240                 }
35241         }
35242 }
35243
35244 func (obj *ToolCaps) deserialize(r io.Reader) {
35245         if _ = (*(*(struct {
35246                 //mt:if _ = %s; false
35247                 NonNil bool
35248
35249                 AttackCooldown float32
35250                 MaxDropLvl     int16
35251
35252                 //mt:len32
35253                 GroupCaps []ToolGroupCap
35254
35255                 //mt:len32
35256                 DmgGroups []Group
35257
35258                 //mt:32tou16
35259                 PunchUses int32
35260         }))(obj)); false {
35261                 {
35262                         p := &(*(*(struct {
35263                                 //mt:if _ = %s; false
35264                                 NonNil bool
35265
35266                                 AttackCooldown float32
35267                                 MaxDropLvl     int16
35268
35269                                 //mt:len32
35270                                 GroupCaps []ToolGroupCap
35271
35272                                 //mt:len32
35273                                 DmgGroups []Group
35274
35275                                 //mt:32tou16
35276                                 PunchUses int32
35277                         }))(obj)).NonNil
35278                         switch n := read8(r); n {
35279                         case 0:
35280                                 *p = false
35281                         case 1:
35282                                 *p = true
35283                         default:
35284                                 chk(fmt.Errorf("invalid bool: %d", n))
35285                         }
35286                 }
35287         }
35288         {
35289                 var n uint16
35290                 {
35291                         p := &n
35292                         *p = read16(r)
35293                 }
35294                 r := &io.LimitedReader{R: r, N: int64(n)}
35295                 if r.N > 0 {
35296                         (*(*(struct {
35297                                 //mt:if _ = %s; false
35298                                 NonNil bool
35299
35300                                 AttackCooldown float32
35301                                 MaxDropLvl     int16
35302
35303                                 //mt:len32
35304                                 GroupCaps []ToolGroupCap
35305
35306                                 //mt:len32
35307                                 DmgGroups []Group
35308
35309                                 //mt:32tou16
35310                                 PunchUses int32
35311                         }))(obj)).NonNil = true
35312                 } /**/
35313                 {
35314                         if (*(*(struct {
35315                                 //mt:if _ = %s; false
35316                                 NonNil bool
35317
35318                                 AttackCooldown float32
35319                                 MaxDropLvl     int16
35320
35321                                 //mt:len32
35322                                 GroupCaps []ToolGroupCap
35323
35324                                 //mt:len32
35325                                 DmgGroups []Group
35326
35327                                 //mt:32tou16
35328                                 PunchUses int32
35329                         }))(obj)).NonNil {
35330                                 {
35331                                         var local396 uint8
35332                                         local397 := uint8(5)
35333                                         {
35334                                                 p := &local396
35335                                                 *p = read8(r)
35336                                         }
35337                                         if local396 != local397 {
35338                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local396))
35339                                         }
35340                                 }
35341                                 {
35342                                         p := &(*(*(struct {
35343                                                 //mt:if _ = %s; false
35344                                                 NonNil bool
35345
35346                                                 AttackCooldown float32
35347                                                 MaxDropLvl     int16
35348
35349                                                 //mt:len32
35350                                                 GroupCaps []ToolGroupCap
35351
35352                                                 //mt:len32
35353                                                 DmgGroups []Group
35354
35355                                                 //mt:32tou16
35356                                                 PunchUses int32
35357                                         }))(obj)).AttackCooldown
35358                                         *p = math.Float32frombits(read32(r))
35359                                 }
35360                                 {
35361                                         p := &(*(*(struct {
35362                                                 //mt:if _ = %s; false
35363                                                 NonNil bool
35364
35365                                                 AttackCooldown float32
35366                                                 MaxDropLvl     int16
35367
35368                                                 //mt:len32
35369                                                 GroupCaps []ToolGroupCap
35370
35371                                                 //mt:len32
35372                                                 DmgGroups []Group
35373
35374                                                 //mt:32tou16
35375                                                 PunchUses int32
35376                                         }))(obj)).MaxDropLvl
35377                                         *p = int16(read16(r))
35378                                 }
35379                                 var local398 uint32
35380                                 {
35381                                         p := &local398
35382                                         *p = read32(r)
35383                                 }
35384                                 ((*(*(struct {
35385                                         //mt:if _ = %s; false
35386                                         NonNil bool
35387
35388                                         AttackCooldown float32
35389                                         MaxDropLvl     int16
35390
35391                                         //mt:len32
35392                                         GroupCaps []ToolGroupCap
35393
35394                                         //mt:len32
35395                                         DmgGroups []Group
35396
35397                                         //mt:32tou16
35398                                         PunchUses int32
35399                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local398)
35400                                 for local399 := range (*(*(struct {
35401                                         //mt:if _ = %s; false
35402                                         NonNil bool
35403
35404                                         AttackCooldown float32
35405                                         MaxDropLvl     int16
35406
35407                                         //mt:len32
35408                                         GroupCaps []ToolGroupCap
35409
35410                                         //mt:len32
35411                                         DmgGroups []Group
35412
35413                                         //mt:32tou16
35414                                         PunchUses int32
35415                                 }))(obj)).GroupCaps {
35416                                         if err := pcall(func() {
35417                                                 (((*(*(struct {
35418                                                         //mt:if _ = %s; false
35419                                                         NonNil bool
35420
35421                                                         AttackCooldown float32
35422                                                         MaxDropLvl     int16
35423
35424                                                         //mt:len32
35425                                                         GroupCaps []ToolGroupCap
35426
35427                                                         //mt:len32
35428                                                         DmgGroups []Group
35429
35430                                                         //mt:32tou16
35431                                                         PunchUses int32
35432                                                 }))(obj)).GroupCaps)[local399]).deserialize(r)
35433                                         }); err != nil {
35434                                                 if err == io.EOF {
35435                                                         chk(io.EOF)
35436                                                 }
35437                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
35438                                         }
35439                                 }
35440                                 var local400 uint32
35441                                 {
35442                                         p := &local400
35443                                         *p = read32(r)
35444                                 }
35445                                 ((*(*(struct {
35446                                         //mt:if _ = %s; false
35447                                         NonNil bool
35448
35449                                         AttackCooldown float32
35450                                         MaxDropLvl     int16
35451
35452                                         //mt:len32
35453                                         GroupCaps []ToolGroupCap
35454
35455                                         //mt:len32
35456                                         DmgGroups []Group
35457
35458                                         //mt:32tou16
35459                                         PunchUses int32
35460                                 }))(obj)).DmgGroups) = make([]Group, local400)
35461                                 for local401 := range (*(*(struct {
35462                                         //mt:if _ = %s; false
35463                                         NonNil bool
35464
35465                                         AttackCooldown float32
35466                                         MaxDropLvl     int16
35467
35468                                         //mt:len32
35469                                         GroupCaps []ToolGroupCap
35470
35471                                         //mt:len32
35472                                         DmgGroups []Group
35473
35474                                         //mt:32tou16
35475                                         PunchUses int32
35476                                 }))(obj)).DmgGroups {
35477                                         if err := pcall(func() {
35478                                                 (((*(*(struct {
35479                                                         //mt:if _ = %s; false
35480                                                         NonNil bool
35481
35482                                                         AttackCooldown float32
35483                                                         MaxDropLvl     int16
35484
35485                                                         //mt:len32
35486                                                         GroupCaps []ToolGroupCap
35487
35488                                                         //mt:len32
35489                                                         DmgGroups []Group
35490
35491                                                         //mt:32tou16
35492                                                         PunchUses int32
35493                                                 }))(obj)).DmgGroups)[local401]).deserialize(r)
35494                                         }); err != nil {
35495                                                 if err == io.EOF {
35496                                                         chk(io.EOF)
35497                                                 }
35498                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
35499                                         }
35500                                 }
35501                                 var local402 uint16
35502                                 {
35503                                         p := &local402
35504                                         *p = read16(r)
35505                                 }
35506                                 (*(*(struct {
35507                                         //mt:if _ = %s; false
35508                                         NonNil bool
35509
35510                                         AttackCooldown float32
35511                                         MaxDropLvl     int16
35512
35513                                         //mt:len32
35514                                         GroupCaps []ToolGroupCap
35515
35516                                         //mt:len32
35517                                         DmgGroups []Group
35518
35519                                         //mt:32tou16
35520                                         PunchUses int32
35521                                 }))(obj)).PunchUses = int32(local402)
35522                         }
35523                 }
35524                 if r.N > 0 {
35525                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
35526                 }
35527         }
35528 }
35529
35530 func (obj *AnimType) serialize(w io.Writer) {
35531         {
35532                 x := *(*(uint8))(obj)
35533                 write8(w, uint8(x))
35534         }
35535 }
35536
35537 func (obj *AnimType) deserialize(r io.Reader) {
35538         {
35539                 p := &*(*(uint8))(obj)
35540                 *p = read8(r)
35541         }
35542 }
35543
35544 func (obj *HUDType) serialize(w io.Writer) {
35545         {
35546                 x := *(*(uint8))(obj)
35547                 write8(w, uint8(x))
35548         }
35549 }
35550
35551 func (obj *HUDType) deserialize(r io.Reader) {
35552         {
35553                 p := &*(*(uint8))(obj)
35554                 *p = read8(r)
35555         }
35556 }
35557
35558 func (obj *Box) serialize(w io.Writer) {
35559         for local403 := range *(*([2]Vec))(obj) {
35560                 if err := pcall(func() {
35561                         ((*(*([2]Vec))(obj))[local403]).serialize(w)
35562                 }); err != nil {
35563                         if err == io.EOF {
35564                                 chk(io.EOF)
35565                         }
35566                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
35567                 }
35568         }
35569 }
35570
35571 func (obj *Box) deserialize(r io.Reader) {
35572         for local404 := range *(*([2]Vec))(obj) {
35573                 if err := pcall(func() {
35574                         ((*(*([2]Vec))(obj))[local404]).deserialize(r)
35575                 }); err != nil {
35576                         if err == io.EOF {
35577                                 chk(io.EOF)
35578                         }
35579                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
35580                 }
35581         }
35582 }
35583
35584 func (obj *TileFlags) serialize(w io.Writer) {
35585         {
35586                 x := *(*(uint16))(obj)
35587                 write16(w, uint16(x))
35588         }
35589 }
35590
35591 func (obj *TileFlags) deserialize(r io.Reader) {
35592         {
35593                 p := &*(*(uint16))(obj)
35594                 *p = read16(r)
35595         }
35596 }
35597
35598 func (obj *AlignType) serialize(w io.Writer) {
35599         {
35600                 x := *(*(uint8))(obj)
35601                 write8(w, uint8(x))
35602         }
35603 }
35604
35605 func (obj *AlignType) deserialize(r io.Reader) {
35606         {
35607                 p := &*(*(uint8))(obj)
35608                 *p = read8(r)
35609         }
35610 }
35611
35612 func (obj *NodeBoxType) serialize(w io.Writer) {
35613         {
35614                 x := *(*(uint8))(obj)
35615                 write8(w, uint8(x))
35616         }
35617 }
35618
35619 func (obj *NodeBoxType) deserialize(r io.Reader) {
35620         {
35621                 p := &*(*(uint8))(obj)
35622                 *p = read8(r)
35623         }
35624 }
35625
35626 func (obj *DirBoxes) serialize(w io.Writer) {
35627         if len(((*(*(struct {
35628                 Top, Bot                 []Box
35629                 Front, Left, Back, Right []Box
35630         }))(obj)).Top)) > math.MaxUint16 {
35631                 chk(ErrTooLong)
35632         }
35633         {
35634                 x := uint16(len(((*(*(struct {
35635                         Top, Bot                 []Box
35636                         Front, Left, Back, Right []Box
35637                 }))(obj)).Top)))
35638                 write16(w, uint16(x))
35639         }
35640         for local405 := range (*(*(struct {
35641                 Top, Bot                 []Box
35642                 Front, Left, Back, Right []Box
35643         }))(obj)).Top {
35644                 if err := pcall(func() {
35645                         (((*(*(struct {
35646                                 Top, Bot                 []Box
35647                                 Front, Left, Back, Right []Box
35648                         }))(obj)).Top)[local405]).serialize(w)
35649                 }); err != nil {
35650                         if err == io.EOF {
35651                                 chk(io.EOF)
35652                         }
35653                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35654                 }
35655         }
35656         if len(((*(*(struct {
35657                 Top, Bot                 []Box
35658                 Front, Left, Back, Right []Box
35659         }))(obj)).Bot)) > math.MaxUint16 {
35660                 chk(ErrTooLong)
35661         }
35662         {
35663                 x := uint16(len(((*(*(struct {
35664                         Top, Bot                 []Box
35665                         Front, Left, Back, Right []Box
35666                 }))(obj)).Bot)))
35667                 write16(w, uint16(x))
35668         }
35669         for local406 := range (*(*(struct {
35670                 Top, Bot                 []Box
35671                 Front, Left, Back, Right []Box
35672         }))(obj)).Bot {
35673                 if err := pcall(func() {
35674                         (((*(*(struct {
35675                                 Top, Bot                 []Box
35676                                 Front, Left, Back, Right []Box
35677                         }))(obj)).Bot)[local406]).serialize(w)
35678                 }); err != nil {
35679                         if err == io.EOF {
35680                                 chk(io.EOF)
35681                         }
35682                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35683                 }
35684         }
35685         if len(((*(*(struct {
35686                 Top, Bot                 []Box
35687                 Front, Left, Back, Right []Box
35688         }))(obj)).Front)) > math.MaxUint16 {
35689                 chk(ErrTooLong)
35690         }
35691         {
35692                 x := uint16(len(((*(*(struct {
35693                         Top, Bot                 []Box
35694                         Front, Left, Back, Right []Box
35695                 }))(obj)).Front)))
35696                 write16(w, uint16(x))
35697         }
35698         for local407 := range (*(*(struct {
35699                 Top, Bot                 []Box
35700                 Front, Left, Back, Right []Box
35701         }))(obj)).Front {
35702                 if err := pcall(func() {
35703                         (((*(*(struct {
35704                                 Top, Bot                 []Box
35705                                 Front, Left, Back, Right []Box
35706                         }))(obj)).Front)[local407]).serialize(w)
35707                 }); err != nil {
35708                         if err == io.EOF {
35709                                 chk(io.EOF)
35710                         }
35711                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35712                 }
35713         }
35714         if len(((*(*(struct {
35715                 Top, Bot                 []Box
35716                 Front, Left, Back, Right []Box
35717         }))(obj)).Left)) > math.MaxUint16 {
35718                 chk(ErrTooLong)
35719         }
35720         {
35721                 x := uint16(len(((*(*(struct {
35722                         Top, Bot                 []Box
35723                         Front, Left, Back, Right []Box
35724                 }))(obj)).Left)))
35725                 write16(w, uint16(x))
35726         }
35727         for local408 := range (*(*(struct {
35728                 Top, Bot                 []Box
35729                 Front, Left, Back, Right []Box
35730         }))(obj)).Left {
35731                 if err := pcall(func() {
35732                         (((*(*(struct {
35733                                 Top, Bot                 []Box
35734                                 Front, Left, Back, Right []Box
35735                         }))(obj)).Left)[local408]).serialize(w)
35736                 }); err != nil {
35737                         if err == io.EOF {
35738                                 chk(io.EOF)
35739                         }
35740                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35741                 }
35742         }
35743         if len(((*(*(struct {
35744                 Top, Bot                 []Box
35745                 Front, Left, Back, Right []Box
35746         }))(obj)).Back)) > math.MaxUint16 {
35747                 chk(ErrTooLong)
35748         }
35749         {
35750                 x := uint16(len(((*(*(struct {
35751                         Top, Bot                 []Box
35752                         Front, Left, Back, Right []Box
35753                 }))(obj)).Back)))
35754                 write16(w, uint16(x))
35755         }
35756         for local409 := range (*(*(struct {
35757                 Top, Bot                 []Box
35758                 Front, Left, Back, Right []Box
35759         }))(obj)).Back {
35760                 if err := pcall(func() {
35761                         (((*(*(struct {
35762                                 Top, Bot                 []Box
35763                                 Front, Left, Back, Right []Box
35764                         }))(obj)).Back)[local409]).serialize(w)
35765                 }); err != nil {
35766                         if err == io.EOF {
35767                                 chk(io.EOF)
35768                         }
35769                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35770                 }
35771         }
35772         if len(((*(*(struct {
35773                 Top, Bot                 []Box
35774                 Front, Left, Back, Right []Box
35775         }))(obj)).Right)) > math.MaxUint16 {
35776                 chk(ErrTooLong)
35777         }
35778         {
35779                 x := uint16(len(((*(*(struct {
35780                         Top, Bot                 []Box
35781                         Front, Left, Back, Right []Box
35782                 }))(obj)).Right)))
35783                 write16(w, uint16(x))
35784         }
35785         for local410 := range (*(*(struct {
35786                 Top, Bot                 []Box
35787                 Front, Left, Back, Right []Box
35788         }))(obj)).Right {
35789                 if err := pcall(func() {
35790                         (((*(*(struct {
35791                                 Top, Bot                 []Box
35792                                 Front, Left, Back, Right []Box
35793                         }))(obj)).Right)[local410]).serialize(w)
35794                 }); err != nil {
35795                         if err == io.EOF {
35796                                 chk(io.EOF)
35797                         }
35798                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35799                 }
35800         }
35801 }
35802
35803 func (obj *DirBoxes) deserialize(r io.Reader) {
35804         var local411 uint16
35805         {
35806                 p := &local411
35807                 *p = read16(r)
35808         }
35809         ((*(*(struct {
35810                 Top, Bot                 []Box
35811                 Front, Left, Back, Right []Box
35812         }))(obj)).Top) = make([]Box, local411)
35813         for local412 := range (*(*(struct {
35814                 Top, Bot                 []Box
35815                 Front, Left, Back, Right []Box
35816         }))(obj)).Top {
35817                 if err := pcall(func() {
35818                         (((*(*(struct {
35819                                 Top, Bot                 []Box
35820                                 Front, Left, Back, Right []Box
35821                         }))(obj)).Top)[local412]).deserialize(r)
35822                 }); err != nil {
35823                         if err == io.EOF {
35824                                 chk(io.EOF)
35825                         }
35826                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35827                 }
35828         }
35829         var local413 uint16
35830         {
35831                 p := &local413
35832                 *p = read16(r)
35833         }
35834         ((*(*(struct {
35835                 Top, Bot                 []Box
35836                 Front, Left, Back, Right []Box
35837         }))(obj)).Bot) = make([]Box, local413)
35838         for local414 := range (*(*(struct {
35839                 Top, Bot                 []Box
35840                 Front, Left, Back, Right []Box
35841         }))(obj)).Bot {
35842                 if err := pcall(func() {
35843                         (((*(*(struct {
35844                                 Top, Bot                 []Box
35845                                 Front, Left, Back, Right []Box
35846                         }))(obj)).Bot)[local414]).deserialize(r)
35847                 }); err != nil {
35848                         if err == io.EOF {
35849                                 chk(io.EOF)
35850                         }
35851                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35852                 }
35853         }
35854         var local415 uint16
35855         {
35856                 p := &local415
35857                 *p = read16(r)
35858         }
35859         ((*(*(struct {
35860                 Top, Bot                 []Box
35861                 Front, Left, Back, Right []Box
35862         }))(obj)).Front) = make([]Box, local415)
35863         for local416 := range (*(*(struct {
35864                 Top, Bot                 []Box
35865                 Front, Left, Back, Right []Box
35866         }))(obj)).Front {
35867                 if err := pcall(func() {
35868                         (((*(*(struct {
35869                                 Top, Bot                 []Box
35870                                 Front, Left, Back, Right []Box
35871                         }))(obj)).Front)[local416]).deserialize(r)
35872                 }); err != nil {
35873                         if err == io.EOF {
35874                                 chk(io.EOF)
35875                         }
35876                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35877                 }
35878         }
35879         var local417 uint16
35880         {
35881                 p := &local417
35882                 *p = read16(r)
35883         }
35884         ((*(*(struct {
35885                 Top, Bot                 []Box
35886                 Front, Left, Back, Right []Box
35887         }))(obj)).Left) = make([]Box, local417)
35888         for local418 := range (*(*(struct {
35889                 Top, Bot                 []Box
35890                 Front, Left, Back, Right []Box
35891         }))(obj)).Left {
35892                 if err := pcall(func() {
35893                         (((*(*(struct {
35894                                 Top, Bot                 []Box
35895                                 Front, Left, Back, Right []Box
35896                         }))(obj)).Left)[local418]).deserialize(r)
35897                 }); err != nil {
35898                         if err == io.EOF {
35899                                 chk(io.EOF)
35900                         }
35901                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35902                 }
35903         }
35904         var local419 uint16
35905         {
35906                 p := &local419
35907                 *p = read16(r)
35908         }
35909         ((*(*(struct {
35910                 Top, Bot                 []Box
35911                 Front, Left, Back, Right []Box
35912         }))(obj)).Back) = make([]Box, local419)
35913         for local420 := range (*(*(struct {
35914                 Top, Bot                 []Box
35915                 Front, Left, Back, Right []Box
35916         }))(obj)).Back {
35917                 if err := pcall(func() {
35918                         (((*(*(struct {
35919                                 Top, Bot                 []Box
35920                                 Front, Left, Back, Right []Box
35921                         }))(obj)).Back)[local420]).deserialize(r)
35922                 }); err != nil {
35923                         if err == io.EOF {
35924                                 chk(io.EOF)
35925                         }
35926                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35927                 }
35928         }
35929         var local421 uint16
35930         {
35931                 p := &local421
35932                 *p = read16(r)
35933         }
35934         ((*(*(struct {
35935                 Top, Bot                 []Box
35936                 Front, Left, Back, Right []Box
35937         }))(obj)).Right) = make([]Box, local421)
35938         for local422 := range (*(*(struct {
35939                 Top, Bot                 []Box
35940                 Front, Left, Back, Right []Box
35941         }))(obj)).Right {
35942                 if err := pcall(func() {
35943                         (((*(*(struct {
35944                                 Top, Bot                 []Box
35945                                 Front, Left, Back, Right []Box
35946                         }))(obj)).Right)[local422]).deserialize(r)
35947                 }); err != nil {
35948                         if err == io.EOF {
35949                                 chk(io.EOF)
35950                         }
35951                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35952                 }
35953         }
35954 }
35955
35956 func (obj *ToolGroupCap) serialize(w io.Writer) {
35957         if len(([]byte((*(*(struct {
35958                 Name string
35959
35960                 //mt:32to16
35961                 Uses int32
35962
35963                 MaxLvl int16
35964
35965                 //mt:len32
35966                 Times []DigTime
35967         }))(obj)).Name))) > math.MaxUint16 {
35968                 chk(ErrTooLong)
35969         }
35970         {
35971                 x := uint16(len(([]byte((*(*(struct {
35972                         Name string
35973
35974                         //mt:32to16
35975                         Uses int32
35976
35977                         MaxLvl int16
35978
35979                         //mt:len32
35980                         Times []DigTime
35981                 }))(obj)).Name))))
35982                 write16(w, uint16(x))
35983         }
35984         {
35985                 _, err := w.Write(([]byte((*(*(struct {
35986                         Name string
35987
35988                         //mt:32to16
35989                         Uses int32
35990
35991                         MaxLvl int16
35992
35993                         //mt:len32
35994                         Times []DigTime
35995                 }))(obj)).Name))[:])
35996                 chk(err)
35997         }
35998         {
35999                 x := int16((*(*(struct {
36000                         Name string
36001
36002                         //mt:32to16
36003                         Uses int32
36004
36005                         MaxLvl int16
36006
36007                         //mt:len32
36008                         Times []DigTime
36009                 }))(obj)).Uses)
36010                 write16(w, uint16(x))
36011         }
36012         {
36013                 x := (*(*(struct {
36014                         Name string
36015
36016                         //mt:32to16
36017                         Uses int32
36018
36019                         MaxLvl int16
36020
36021                         //mt:len32
36022                         Times []DigTime
36023                 }))(obj)).MaxLvl
36024                 write16(w, uint16(x))
36025         }
36026         if len(((*(*(struct {
36027                 Name string
36028
36029                 //mt:32to16
36030                 Uses int32
36031
36032                 MaxLvl int16
36033
36034                 //mt:len32
36035                 Times []DigTime
36036         }))(obj)).Times)) > math.MaxUint32 {
36037                 chk(ErrTooLong)
36038         }
36039         {
36040                 x := uint32(len(((*(*(struct {
36041                         Name string
36042
36043                         //mt:32to16
36044                         Uses int32
36045
36046                         MaxLvl int16
36047
36048                         //mt:len32
36049                         Times []DigTime
36050                 }))(obj)).Times)))
36051                 write32(w, uint32(x))
36052         }
36053         for local423 := range (*(*(struct {
36054                 Name string
36055
36056                 //mt:32to16
36057                 Uses int32
36058
36059                 MaxLvl int16
36060
36061                 //mt:len32
36062                 Times []DigTime
36063         }))(obj)).Times {
36064                 if err := pcall(func() {
36065                         (((*(*(struct {
36066                                 Name string
36067
36068                                 //mt:32to16
36069                                 Uses int32
36070
36071                                 MaxLvl int16
36072
36073                                 //mt:len32
36074                                 Times []DigTime
36075                         }))(obj)).Times)[local423]).serialize(w)
36076                 }); err != nil {
36077                         if err == io.EOF {
36078                                 chk(io.EOF)
36079                         }
36080                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
36081                 }
36082         }
36083 }
36084
36085 func (obj *ToolGroupCap) deserialize(r io.Reader) {
36086         var local424 []uint8
36087         var local425 uint16
36088         {
36089                 p := &local425
36090                 *p = read16(r)
36091         }
36092         (local424) = make([]uint8, local425)
36093         {
36094                 _, err := io.ReadFull(r, (local424)[:])
36095                 chk(err)
36096         }
36097         ((*(*(struct {
36098                 Name string
36099
36100                 //mt:32to16
36101                 Uses int32
36102
36103                 MaxLvl int16
36104
36105                 //mt:len32
36106                 Times []DigTime
36107         }))(obj)).Name) = string(local424)
36108         var local426 int16
36109         {
36110                 p := &local426
36111                 *p = int16(read16(r))
36112         }
36113         (*(*(struct {
36114                 Name string
36115
36116                 //mt:32to16
36117                 Uses int32
36118
36119                 MaxLvl int16
36120
36121                 //mt:len32
36122                 Times []DigTime
36123         }))(obj)).Uses = int32(local426)
36124         {
36125                 p := &(*(*(struct {
36126                         Name string
36127
36128                         //mt:32to16
36129                         Uses int32
36130
36131                         MaxLvl int16
36132
36133                         //mt:len32
36134                         Times []DigTime
36135                 }))(obj)).MaxLvl
36136                 *p = int16(read16(r))
36137         }
36138         var local427 uint32
36139         {
36140                 p := &local427
36141                 *p = read32(r)
36142         }
36143         ((*(*(struct {
36144                 Name string
36145
36146                 //mt:32to16
36147                 Uses int32
36148
36149                 MaxLvl int16
36150
36151                 //mt:len32
36152                 Times []DigTime
36153         }))(obj)).Times) = make([]DigTime, local427)
36154         for local428 := range (*(*(struct {
36155                 Name string
36156
36157                 //mt:32to16
36158                 Uses int32
36159
36160                 MaxLvl int16
36161
36162                 //mt:len32
36163                 Times []DigTime
36164         }))(obj)).Times {
36165                 if err := pcall(func() {
36166                         (((*(*(struct {
36167                                 Name string
36168
36169                                 //mt:32to16
36170                                 Uses int32
36171
36172                                 MaxLvl int16
36173
36174                                 //mt:len32
36175                                 Times []DigTime
36176                         }))(obj)).Times)[local428]).deserialize(r)
36177                 }); err != nil {
36178                         if err == io.EOF {
36179                                 chk(io.EOF)
36180                         }
36181                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
36182                 }
36183         }
36184 }
36185
36186 func (obj *DigTime) serialize(w io.Writer) {
36187         {
36188                 x := (*(*(struct {
36189                         Rating int16
36190                         Time   float32
36191                 }))(obj)).Rating
36192                 write16(w, uint16(x))
36193         }
36194         {
36195                 x := (*(*(struct {
36196                         Rating int16
36197                         Time   float32
36198                 }))(obj)).Time
36199                 write32(w, math.Float32bits(x))
36200         }
36201 }
36202
36203 func (obj *DigTime) deserialize(r io.Reader) {
36204         {
36205                 p := &(*(*(struct {
36206                         Rating int16
36207                         Time   float32
36208                 }))(obj)).Rating
36209                 *p = int16(read16(r))
36210         }
36211         {
36212                 p := &(*(*(struct {
36213                         Rating int16
36214                         Time   float32
36215                 }))(obj)).Time
36216                 *p = math.Float32frombits(read32(r))
36217         }
36218 }