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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
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    HUDStyleFlags
27669                 }))(obj)).Text2))[:])
27670                 chk(err)
27671         }
27672         if err := pcall(func() {
27673                 ((*(*(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    HUDStyleFlags
27690                 }))(obj)).Style).serialize(w)
27691         }); err != nil {
27692                 if err == io.EOF {
27693                         chk(io.EOF)
27694                 }
27695                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
27696         }
27697 }
27698
27699 func (obj *HUD) deserialize(r io.Reader) {
27700         if err := pcall(func() {
27701                 ((*(*(struct {
27702                         Type HUDType
27703
27704                         Pos      [2]float32
27705                         Name     string
27706                         Scale    [2]float32
27707                         Text     string
27708                         Number   uint32
27709                         Item     uint32
27710                         Dir      uint32
27711                         Align    [2]float32
27712                         Offset   [2]float32
27713                         WorldPos Pos
27714                         Size     [2]int32
27715                         ZIndex   int16
27716                         Text2    string
27717                         Style    HUDStyleFlags
27718                 }))(obj)).Type).deserialize(r)
27719         }); err != nil {
27720                 if err == io.EOF {
27721                         chk(io.EOF)
27722                 }
27723                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
27724         }
27725         for local317 := range (*(*(struct {
27726                 Type HUDType
27727
27728                 Pos      [2]float32
27729                 Name     string
27730                 Scale    [2]float32
27731                 Text     string
27732                 Number   uint32
27733                 Item     uint32
27734                 Dir      uint32
27735                 Align    [2]float32
27736                 Offset   [2]float32
27737                 WorldPos Pos
27738                 Size     [2]int32
27739                 ZIndex   int16
27740                 Text2    string
27741                 Style    HUDStyleFlags
27742         }))(obj)).Pos {
27743                 {
27744                         p := &((*(*(struct {
27745                                 Type HUDType
27746
27747                                 Pos      [2]float32
27748                                 Name     string
27749                                 Scale    [2]float32
27750                                 Text     string
27751                                 Number   uint32
27752                                 Item     uint32
27753                                 Dir      uint32
27754                                 Align    [2]float32
27755                                 Offset   [2]float32
27756                                 WorldPos Pos
27757                                 Size     [2]int32
27758                                 ZIndex   int16
27759                                 Text2    string
27760                                 Style    HUDStyleFlags
27761                         }))(obj)).Pos)[local317]
27762                         *p = math.Float32frombits(read32(r))
27763                 }
27764         }
27765         var local318 []uint8
27766         var local319 uint16
27767         {
27768                 p := &local319
27769                 *p = read16(r)
27770         }
27771         (local318) = make([]uint8, local319)
27772         {
27773                 _, err := io.ReadFull(r, (local318)[:])
27774                 chk(err)
27775         }
27776         ((*(*(struct {
27777                 Type HUDType
27778
27779                 Pos      [2]float32
27780                 Name     string
27781                 Scale    [2]float32
27782                 Text     string
27783                 Number   uint32
27784                 Item     uint32
27785                 Dir      uint32
27786                 Align    [2]float32
27787                 Offset   [2]float32
27788                 WorldPos Pos
27789                 Size     [2]int32
27790                 ZIndex   int16
27791                 Text2    string
27792                 Style    HUDStyleFlags
27793         }))(obj)).Name) = string(local318)
27794         for local320 := range (*(*(struct {
27795                 Type HUDType
27796
27797                 Pos      [2]float32
27798                 Name     string
27799                 Scale    [2]float32
27800                 Text     string
27801                 Number   uint32
27802                 Item     uint32
27803                 Dir      uint32
27804                 Align    [2]float32
27805                 Offset   [2]float32
27806                 WorldPos Pos
27807                 Size     [2]int32
27808                 ZIndex   int16
27809                 Text2    string
27810                 Style    HUDStyleFlags
27811         }))(obj)).Scale {
27812                 {
27813                         p := &((*(*(struct {
27814                                 Type HUDType
27815
27816                                 Pos      [2]float32
27817                                 Name     string
27818                                 Scale    [2]float32
27819                                 Text     string
27820                                 Number   uint32
27821                                 Item     uint32
27822                                 Dir      uint32
27823                                 Align    [2]float32
27824                                 Offset   [2]float32
27825                                 WorldPos Pos
27826                                 Size     [2]int32
27827                                 ZIndex   int16
27828                                 Text2    string
27829                                 Style    HUDStyleFlags
27830                         }))(obj)).Scale)[local320]
27831                         *p = math.Float32frombits(read32(r))
27832                 }
27833         }
27834         var local321 []uint8
27835         var local322 uint16
27836         {
27837                 p := &local322
27838                 *p = read16(r)
27839         }
27840         (local321) = make([]uint8, local322)
27841         {
27842                 _, err := io.ReadFull(r, (local321)[:])
27843                 chk(err)
27844         }
27845         ((*(*(struct {
27846                 Type HUDType
27847
27848                 Pos      [2]float32
27849                 Name     string
27850                 Scale    [2]float32
27851                 Text     string
27852                 Number   uint32
27853                 Item     uint32
27854                 Dir      uint32
27855                 Align    [2]float32
27856                 Offset   [2]float32
27857                 WorldPos Pos
27858                 Size     [2]int32
27859                 ZIndex   int16
27860                 Text2    string
27861                 Style    HUDStyleFlags
27862         }))(obj)).Text) = string(local321)
27863         {
27864                 p := &(*(*(struct {
27865                         Type HUDType
27866
27867                         Pos      [2]float32
27868                         Name     string
27869                         Scale    [2]float32
27870                         Text     string
27871                         Number   uint32
27872                         Item     uint32
27873                         Dir      uint32
27874                         Align    [2]float32
27875                         Offset   [2]float32
27876                         WorldPos Pos
27877                         Size     [2]int32
27878                         ZIndex   int16
27879                         Text2    string
27880                         Style    HUDStyleFlags
27881                 }))(obj)).Number
27882                 *p = read32(r)
27883         }
27884         {
27885                 p := &(*(*(struct {
27886                         Type HUDType
27887
27888                         Pos      [2]float32
27889                         Name     string
27890                         Scale    [2]float32
27891                         Text     string
27892                         Number   uint32
27893                         Item     uint32
27894                         Dir      uint32
27895                         Align    [2]float32
27896                         Offset   [2]float32
27897                         WorldPos Pos
27898                         Size     [2]int32
27899                         ZIndex   int16
27900                         Text2    string
27901                         Style    HUDStyleFlags
27902                 }))(obj)).Item
27903                 *p = read32(r)
27904         }
27905         {
27906                 p := &(*(*(struct {
27907                         Type HUDType
27908
27909                         Pos      [2]float32
27910                         Name     string
27911                         Scale    [2]float32
27912                         Text     string
27913                         Number   uint32
27914                         Item     uint32
27915                         Dir      uint32
27916                         Align    [2]float32
27917                         Offset   [2]float32
27918                         WorldPos Pos
27919                         Size     [2]int32
27920                         ZIndex   int16
27921                         Text2    string
27922                         Style    HUDStyleFlags
27923                 }))(obj)).Dir
27924                 *p = read32(r)
27925         }
27926         for local323 := range (*(*(struct {
27927                 Type HUDType
27928
27929                 Pos      [2]float32
27930                 Name     string
27931                 Scale    [2]float32
27932                 Text     string
27933                 Number   uint32
27934                 Item     uint32
27935                 Dir      uint32
27936                 Align    [2]float32
27937                 Offset   [2]float32
27938                 WorldPos Pos
27939                 Size     [2]int32
27940                 ZIndex   int16
27941                 Text2    string
27942                 Style    HUDStyleFlags
27943         }))(obj)).Align {
27944                 {
27945                         p := &((*(*(struct {
27946                                 Type HUDType
27947
27948                                 Pos      [2]float32
27949                                 Name     string
27950                                 Scale    [2]float32
27951                                 Text     string
27952                                 Number   uint32
27953                                 Item     uint32
27954                                 Dir      uint32
27955                                 Align    [2]float32
27956                                 Offset   [2]float32
27957                                 WorldPos Pos
27958                                 Size     [2]int32
27959                                 ZIndex   int16
27960                                 Text2    string
27961                                 Style    HUDStyleFlags
27962                         }))(obj)).Align)[local323]
27963                         *p = math.Float32frombits(read32(r))
27964                 }
27965         }
27966         for local324 := range (*(*(struct {
27967                 Type HUDType
27968
27969                 Pos      [2]float32
27970                 Name     string
27971                 Scale    [2]float32
27972                 Text     string
27973                 Number   uint32
27974                 Item     uint32
27975                 Dir      uint32
27976                 Align    [2]float32
27977                 Offset   [2]float32
27978                 WorldPos Pos
27979                 Size     [2]int32
27980                 ZIndex   int16
27981                 Text2    string
27982                 Style    HUDStyleFlags
27983         }))(obj)).Offset {
27984                 {
27985                         p := &((*(*(struct {
27986                                 Type HUDType
27987
27988                                 Pos      [2]float32
27989                                 Name     string
27990                                 Scale    [2]float32
27991                                 Text     string
27992                                 Number   uint32
27993                                 Item     uint32
27994                                 Dir      uint32
27995                                 Align    [2]float32
27996                                 Offset   [2]float32
27997                                 WorldPos Pos
27998                                 Size     [2]int32
27999                                 ZIndex   int16
28000                                 Text2    string
28001                                 Style    HUDStyleFlags
28002                         }))(obj)).Offset)[local324]
28003                         *p = math.Float32frombits(read32(r))
28004                 }
28005         }
28006         if err := pcall(func() {
28007                 ((*(*(struct {
28008                         Type HUDType
28009
28010                         Pos      [2]float32
28011                         Name     string
28012                         Scale    [2]float32
28013                         Text     string
28014                         Number   uint32
28015                         Item     uint32
28016                         Dir      uint32
28017                         Align    [2]float32
28018                         Offset   [2]float32
28019                         WorldPos Pos
28020                         Size     [2]int32
28021                         ZIndex   int16
28022                         Text2    string
28023                         Style    HUDStyleFlags
28024                 }))(obj)).WorldPos).deserialize(r)
28025         }); err != nil {
28026                 if err == io.EOF {
28027                         chk(io.EOF)
28028                 }
28029                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
28030         }
28031         for local325 := range (*(*(struct {
28032                 Type HUDType
28033
28034                 Pos      [2]float32
28035                 Name     string
28036                 Scale    [2]float32
28037                 Text     string
28038                 Number   uint32
28039                 Item     uint32
28040                 Dir      uint32
28041                 Align    [2]float32
28042                 Offset   [2]float32
28043                 WorldPos Pos
28044                 Size     [2]int32
28045                 ZIndex   int16
28046                 Text2    string
28047                 Style    HUDStyleFlags
28048         }))(obj)).Size {
28049                 {
28050                         p := &((*(*(struct {
28051                                 Type HUDType
28052
28053                                 Pos      [2]float32
28054                                 Name     string
28055                                 Scale    [2]float32
28056                                 Text     string
28057                                 Number   uint32
28058                                 Item     uint32
28059                                 Dir      uint32
28060                                 Align    [2]float32
28061                                 Offset   [2]float32
28062                                 WorldPos Pos
28063                                 Size     [2]int32
28064                                 ZIndex   int16
28065                                 Text2    string
28066                                 Style    HUDStyleFlags
28067                         }))(obj)).Size)[local325]
28068                         *p = int32(read32(r))
28069                 }
28070         }
28071         {
28072                 p := &(*(*(struct {
28073                         Type HUDType
28074
28075                         Pos      [2]float32
28076                         Name     string
28077                         Scale    [2]float32
28078                         Text     string
28079                         Number   uint32
28080                         Item     uint32
28081                         Dir      uint32
28082                         Align    [2]float32
28083                         Offset   [2]float32
28084                         WorldPos Pos
28085                         Size     [2]int32
28086                         ZIndex   int16
28087                         Text2    string
28088                         Style    HUDStyleFlags
28089                 }))(obj)).ZIndex
28090                 *p = int16(read16(r))
28091         }
28092         var local326 []uint8
28093         var local327 uint16
28094         {
28095                 p := &local327
28096                 *p = read16(r)
28097         }
28098         (local326) = make([]uint8, local327)
28099         {
28100                 _, err := io.ReadFull(r, (local326)[:])
28101                 chk(err)
28102         }
28103         ((*(*(struct {
28104                 Type HUDType
28105
28106                 Pos      [2]float32
28107                 Name     string
28108                 Scale    [2]float32
28109                 Text     string
28110                 Number   uint32
28111                 Item     uint32
28112                 Dir      uint32
28113                 Align    [2]float32
28114                 Offset   [2]float32
28115                 WorldPos Pos
28116                 Size     [2]int32
28117                 ZIndex   int16
28118                 Text2    string
28119                 Style    HUDStyleFlags
28120         }))(obj)).Text2) = string(local326)
28121         if err := pcall(func() {
28122                 ((*(*(struct {
28123                         Type HUDType
28124
28125                         Pos      [2]float32
28126                         Name     string
28127                         Scale    [2]float32
28128                         Text     string
28129                         Number   uint32
28130                         Item     uint32
28131                         Dir      uint32
28132                         Align    [2]float32
28133                         Offset   [2]float32
28134                         WorldPos Pos
28135                         Size     [2]int32
28136                         ZIndex   int16
28137                         Text2    string
28138                         Style    HUDStyleFlags
28139                 }))(obj)).Style).deserialize(r)
28140         }); err != nil {
28141                 if err == io.EOF {
28142                         chk(io.EOF)
28143                 }
28144                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
28145         }
28146 }
28147
28148 func (obj *HUDField) serialize(w io.Writer) {
28149         {
28150                 x := *(*(uint8))(obj)
28151                 write8(w, uint8(x))
28152         }
28153 }
28154
28155 func (obj *HUDField) deserialize(r io.Reader) {
28156         {
28157                 p := &*(*(uint8))(obj)
28158                 *p = read8(r)
28159         }
28160 }
28161
28162 func (obj *HUDStyleFlags) serialize(w io.Writer) {
28163         {
28164                 x := *(*(uint32))(obj)
28165                 write32(w, uint32(x))
28166         }
28167 }
28168
28169 func (obj *HUDStyleFlags) deserialize(r io.Reader) {
28170         {
28171                 p := &*(*(uint32))(obj)
28172                 *p = read32(r)
28173         }
28174 }
28175
28176 func (obj *HUDFlags) serialize(w io.Writer) {
28177         {
28178                 x := *(*(uint32))(obj)
28179                 write32(w, uint32(x))
28180         }
28181 }
28182
28183 func (obj *HUDFlags) deserialize(r io.Reader) {
28184         {
28185                 p := &*(*(uint32))(obj)
28186                 *p = read32(r)
28187         }
28188 }
28189
28190 func (obj *HotbarParam) serialize(w io.Writer) {
28191         {
28192                 x := *(*(uint16))(obj)
28193                 write16(w, uint16(x))
28194         }
28195 }
28196
28197 func (obj *HotbarParam) deserialize(r io.Reader) {
28198         {
28199                 p := &*(*(uint16))(obj)
28200                 *p = read16(r)
28201         }
28202 }
28203
28204 func (obj *Texture) serialize(w io.Writer) {
28205         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
28206                 chk(ErrTooLong)
28207         }
28208         {
28209                 x := uint16(len(([]byte(*(*(string))(obj)))))
28210                 write16(w, uint16(x))
28211         }
28212         {
28213                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
28214                 chk(err)
28215         }
28216 }
28217
28218 func (obj *Texture) deserialize(r io.Reader) {
28219         var local328 []uint8
28220         var local329 uint16
28221         {
28222                 p := &local329
28223                 *p = read16(r)
28224         }
28225         (local328) = make([]uint8, local329)
28226         {
28227                 _, err := io.ReadFull(r, (local328)[:])
28228                 chk(err)
28229         }
28230         (*(*(string))(obj)) = string(local328)
28231 }
28232
28233 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
28234         {
28235                 x := *(*(uint8))(obj)
28236                 write8(w, uint8(x))
28237         }
28238 }
28239
28240 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
28241         {
28242                 p := &*(*(uint8))(obj)
28243                 *p = read8(r)
28244         }
28245 }
28246
28247 func (obj *ModChanSig) serialize(w io.Writer) {
28248         {
28249                 x := *(*(uint8))(obj)
28250                 write8(w, uint8(x))
28251         }
28252 }
28253
28254 func (obj *ModChanSig) deserialize(r io.Reader) {
28255         {
28256                 p := &*(*(uint8))(obj)
28257                 *p = read8(r)
28258         }
28259 }
28260
28261 func (obj *AOProps) serialize(w io.Writer) {
28262         {
28263                 local330 := uint8(4)
28264                 {
28265                         x := local330
28266                         write8(w, uint8(x))
28267                 }
28268         }
28269         {
28270                 x := (*(*(struct {
28271                         MaxHP            uint16 // Player only.
28272                         CollideWithNodes bool
28273                         Weight           float32 // deprecated
28274                         ColBox, SelBox   Box
28275                         Pointable        bool
28276                         Visual           string
28277                         VisualSize       [3]float32
28278                         Textures         []Texture
28279                         SpriteSheetSize  [2]int16 // in sprites.
28280                         SpritePos        [2]int16 // in sprite sheet.
28281                         Visible          bool
28282                         MakeFootstepSnds bool
28283                         RotateSpeed      float32 // in radians per second.
28284                         Mesh             string
28285                         Colors           []color.NRGBA
28286                         CollideWithAOs   bool
28287                         StepHeight       float32
28288                         FaceRotateDir    bool
28289                         FaceRotateDirOff float32 // in degrees.
28290                         BackfaceCull     bool
28291                         Nametag          string
28292                         NametagColor     color.NRGBA
28293                         FaceRotateSpeed  float32 // in degrees per second.
28294                         Infotext         string
28295                         Itemstring       string
28296                         Glow             int8
28297                         MaxBreath        uint16  // Player only.
28298                         EyeHeight        float32 // Player only.
28299                         ZoomFOV          float32 // in degrees. Player only.
28300                         UseTextureAlpha  bool
28301                         DmgTextureMod    Texture // suffix
28302                         Shaded           bool
28303                         ShowOnMinimap    bool
28304                         NametagBG        color.NRGBA
28305                 }))(obj)).MaxHP
28306                 write16(w, uint16(x))
28307         }
28308         {
28309                 x := (*(*(struct {
28310                         MaxHP            uint16 // Player only.
28311                         CollideWithNodes bool
28312                         Weight           float32 // deprecated
28313                         ColBox, SelBox   Box
28314                         Pointable        bool
28315                         Visual           string
28316                         VisualSize       [3]float32
28317                         Textures         []Texture
28318                         SpriteSheetSize  [2]int16 // in sprites.
28319                         SpritePos        [2]int16 // in sprite sheet.
28320                         Visible          bool
28321                         MakeFootstepSnds bool
28322                         RotateSpeed      float32 // in radians per second.
28323                         Mesh             string
28324                         Colors           []color.NRGBA
28325                         CollideWithAOs   bool
28326                         StepHeight       float32
28327                         FaceRotateDir    bool
28328                         FaceRotateDirOff float32 // in degrees.
28329                         BackfaceCull     bool
28330                         Nametag          string
28331                         NametagColor     color.NRGBA
28332                         FaceRotateSpeed  float32 // in degrees per second.
28333                         Infotext         string
28334                         Itemstring       string
28335                         Glow             int8
28336                         MaxBreath        uint16  // Player only.
28337                         EyeHeight        float32 // Player only.
28338                         ZoomFOV          float32 // in degrees. Player only.
28339                         UseTextureAlpha  bool
28340                         DmgTextureMod    Texture // suffix
28341                         Shaded           bool
28342                         ShowOnMinimap    bool
28343                         NametagBG        color.NRGBA
28344                 }))(obj)).CollideWithNodes
28345                 if x {
28346                         write8(w, 1)
28347                 } else {
28348                         write8(w, 0)
28349                 }
28350         }
28351         {
28352                 x := (*(*(struct {
28353                         MaxHP            uint16 // Player only.
28354                         CollideWithNodes bool
28355                         Weight           float32 // deprecated
28356                         ColBox, SelBox   Box
28357                         Pointable        bool
28358                         Visual           string
28359                         VisualSize       [3]float32
28360                         Textures         []Texture
28361                         SpriteSheetSize  [2]int16 // in sprites.
28362                         SpritePos        [2]int16 // in sprite sheet.
28363                         Visible          bool
28364                         MakeFootstepSnds bool
28365                         RotateSpeed      float32 // in radians per second.
28366                         Mesh             string
28367                         Colors           []color.NRGBA
28368                         CollideWithAOs   bool
28369                         StepHeight       float32
28370                         FaceRotateDir    bool
28371                         FaceRotateDirOff float32 // in degrees.
28372                         BackfaceCull     bool
28373                         Nametag          string
28374                         NametagColor     color.NRGBA
28375                         FaceRotateSpeed  float32 // in degrees per second.
28376                         Infotext         string
28377                         Itemstring       string
28378                         Glow             int8
28379                         MaxBreath        uint16  // Player only.
28380                         EyeHeight        float32 // Player only.
28381                         ZoomFOV          float32 // in degrees. Player only.
28382                         UseTextureAlpha  bool
28383                         DmgTextureMod    Texture // suffix
28384                         Shaded           bool
28385                         ShowOnMinimap    bool
28386                         NametagBG        color.NRGBA
28387                 }))(obj)).Weight
28388                 write32(w, math.Float32bits(x))
28389         }
28390         if err := pcall(func() {
28391                 ((*(*(struct {
28392                         MaxHP            uint16 // Player only.
28393                         CollideWithNodes bool
28394                         Weight           float32 // deprecated
28395                         ColBox, SelBox   Box
28396                         Pointable        bool
28397                         Visual           string
28398                         VisualSize       [3]float32
28399                         Textures         []Texture
28400                         SpriteSheetSize  [2]int16 // in sprites.
28401                         SpritePos        [2]int16 // in sprite sheet.
28402                         Visible          bool
28403                         MakeFootstepSnds bool
28404                         RotateSpeed      float32 // in radians per second.
28405                         Mesh             string
28406                         Colors           []color.NRGBA
28407                         CollideWithAOs   bool
28408                         StepHeight       float32
28409                         FaceRotateDir    bool
28410                         FaceRotateDirOff float32 // in degrees.
28411                         BackfaceCull     bool
28412                         Nametag          string
28413                         NametagColor     color.NRGBA
28414                         FaceRotateSpeed  float32 // in degrees per second.
28415                         Infotext         string
28416                         Itemstring       string
28417                         Glow             int8
28418                         MaxBreath        uint16  // Player only.
28419                         EyeHeight        float32 // Player only.
28420                         ZoomFOV          float32 // in degrees. Player only.
28421                         UseTextureAlpha  bool
28422                         DmgTextureMod    Texture // suffix
28423                         Shaded           bool
28424                         ShowOnMinimap    bool
28425                         NametagBG        color.NRGBA
28426                 }))(obj)).ColBox).serialize(w)
28427         }); err != nil {
28428                 if err == io.EOF {
28429                         chk(io.EOF)
28430                 }
28431                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
28432         }
28433         if err := pcall(func() {
28434                 ((*(*(struct {
28435                         MaxHP            uint16 // Player only.
28436                         CollideWithNodes bool
28437                         Weight           float32 // deprecated
28438                         ColBox, SelBox   Box
28439                         Pointable        bool
28440                         Visual           string
28441                         VisualSize       [3]float32
28442                         Textures         []Texture
28443                         SpriteSheetSize  [2]int16 // in sprites.
28444                         SpritePos        [2]int16 // in sprite sheet.
28445                         Visible          bool
28446                         MakeFootstepSnds bool
28447                         RotateSpeed      float32 // in radians per second.
28448                         Mesh             string
28449                         Colors           []color.NRGBA
28450                         CollideWithAOs   bool
28451                         StepHeight       float32
28452                         FaceRotateDir    bool
28453                         FaceRotateDirOff float32 // in degrees.
28454                         BackfaceCull     bool
28455                         Nametag          string
28456                         NametagColor     color.NRGBA
28457                         FaceRotateSpeed  float32 // in degrees per second.
28458                         Infotext         string
28459                         Itemstring       string
28460                         Glow             int8
28461                         MaxBreath        uint16  // Player only.
28462                         EyeHeight        float32 // Player only.
28463                         ZoomFOV          float32 // in degrees. Player only.
28464                         UseTextureAlpha  bool
28465                         DmgTextureMod    Texture // suffix
28466                         Shaded           bool
28467                         ShowOnMinimap    bool
28468                         NametagBG        color.NRGBA
28469                 }))(obj)).SelBox).serialize(w)
28470         }); err != nil {
28471                 if err == io.EOF {
28472                         chk(io.EOF)
28473                 }
28474                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
28475         }
28476         {
28477                 x := (*(*(struct {
28478                         MaxHP            uint16 // Player only.
28479                         CollideWithNodes bool
28480                         Weight           float32 // deprecated
28481                         ColBox, SelBox   Box
28482                         Pointable        bool
28483                         Visual           string
28484                         VisualSize       [3]float32
28485                         Textures         []Texture
28486                         SpriteSheetSize  [2]int16 // in sprites.
28487                         SpritePos        [2]int16 // in sprite sheet.
28488                         Visible          bool
28489                         MakeFootstepSnds bool
28490                         RotateSpeed      float32 // in radians per second.
28491                         Mesh             string
28492                         Colors           []color.NRGBA
28493                         CollideWithAOs   bool
28494                         StepHeight       float32
28495                         FaceRotateDir    bool
28496                         FaceRotateDirOff float32 // in degrees.
28497                         BackfaceCull     bool
28498                         Nametag          string
28499                         NametagColor     color.NRGBA
28500                         FaceRotateSpeed  float32 // in degrees per second.
28501                         Infotext         string
28502                         Itemstring       string
28503                         Glow             int8
28504                         MaxBreath        uint16  // Player only.
28505                         EyeHeight        float32 // Player only.
28506                         ZoomFOV          float32 // in degrees. Player only.
28507                         UseTextureAlpha  bool
28508                         DmgTextureMod    Texture // suffix
28509                         Shaded           bool
28510                         ShowOnMinimap    bool
28511                         NametagBG        color.NRGBA
28512                 }))(obj)).Pointable
28513                 if x {
28514                         write8(w, 1)
28515                 } else {
28516                         write8(w, 0)
28517                 }
28518         }
28519         if len(([]byte((*(*(struct {
28520                 MaxHP            uint16 // Player only.
28521                 CollideWithNodes bool
28522                 Weight           float32 // deprecated
28523                 ColBox, SelBox   Box
28524                 Pointable        bool
28525                 Visual           string
28526                 VisualSize       [3]float32
28527                 Textures         []Texture
28528                 SpriteSheetSize  [2]int16 // in sprites.
28529                 SpritePos        [2]int16 // in sprite sheet.
28530                 Visible          bool
28531                 MakeFootstepSnds bool
28532                 RotateSpeed      float32 // in radians per second.
28533                 Mesh             string
28534                 Colors           []color.NRGBA
28535                 CollideWithAOs   bool
28536                 StepHeight       float32
28537                 FaceRotateDir    bool
28538                 FaceRotateDirOff float32 // in degrees.
28539                 BackfaceCull     bool
28540                 Nametag          string
28541                 NametagColor     color.NRGBA
28542                 FaceRotateSpeed  float32 // in degrees per second.
28543                 Infotext         string
28544                 Itemstring       string
28545                 Glow             int8
28546                 MaxBreath        uint16  // Player only.
28547                 EyeHeight        float32 // Player only.
28548                 ZoomFOV          float32 // in degrees. Player only.
28549                 UseTextureAlpha  bool
28550                 DmgTextureMod    Texture // suffix
28551                 Shaded           bool
28552                 ShowOnMinimap    bool
28553                 NametagBG        color.NRGBA
28554         }))(obj)).Visual))) > math.MaxUint16 {
28555                 chk(ErrTooLong)
28556         }
28557         {
28558                 x := uint16(len(([]byte((*(*(struct {
28559                         MaxHP            uint16 // Player only.
28560                         CollideWithNodes bool
28561                         Weight           float32 // deprecated
28562                         ColBox, SelBox   Box
28563                         Pointable        bool
28564                         Visual           string
28565                         VisualSize       [3]float32
28566                         Textures         []Texture
28567                         SpriteSheetSize  [2]int16 // in sprites.
28568                         SpritePos        [2]int16 // in sprite sheet.
28569                         Visible          bool
28570                         MakeFootstepSnds bool
28571                         RotateSpeed      float32 // in radians per second.
28572                         Mesh             string
28573                         Colors           []color.NRGBA
28574                         CollideWithAOs   bool
28575                         StepHeight       float32
28576                         FaceRotateDir    bool
28577                         FaceRotateDirOff float32 // in degrees.
28578                         BackfaceCull     bool
28579                         Nametag          string
28580                         NametagColor     color.NRGBA
28581                         FaceRotateSpeed  float32 // in degrees per second.
28582                         Infotext         string
28583                         Itemstring       string
28584                         Glow             int8
28585                         MaxBreath        uint16  // Player only.
28586                         EyeHeight        float32 // Player only.
28587                         ZoomFOV          float32 // in degrees. Player only.
28588                         UseTextureAlpha  bool
28589                         DmgTextureMod    Texture // suffix
28590                         Shaded           bool
28591                         ShowOnMinimap    bool
28592                         NametagBG        color.NRGBA
28593                 }))(obj)).Visual))))
28594                 write16(w, uint16(x))
28595         }
28596         {
28597                 _, err := w.Write(([]byte((*(*(struct {
28598                         MaxHP            uint16 // Player only.
28599                         CollideWithNodes bool
28600                         Weight           float32 // deprecated
28601                         ColBox, SelBox   Box
28602                         Pointable        bool
28603                         Visual           string
28604                         VisualSize       [3]float32
28605                         Textures         []Texture
28606                         SpriteSheetSize  [2]int16 // in sprites.
28607                         SpritePos        [2]int16 // in sprite sheet.
28608                         Visible          bool
28609                         MakeFootstepSnds bool
28610                         RotateSpeed      float32 // in radians per second.
28611                         Mesh             string
28612                         Colors           []color.NRGBA
28613                         CollideWithAOs   bool
28614                         StepHeight       float32
28615                         FaceRotateDir    bool
28616                         FaceRotateDirOff float32 // in degrees.
28617                         BackfaceCull     bool
28618                         Nametag          string
28619                         NametagColor     color.NRGBA
28620                         FaceRotateSpeed  float32 // in degrees per second.
28621                         Infotext         string
28622                         Itemstring       string
28623                         Glow             int8
28624                         MaxBreath        uint16  // Player only.
28625                         EyeHeight        float32 // Player only.
28626                         ZoomFOV          float32 // in degrees. Player only.
28627                         UseTextureAlpha  bool
28628                         DmgTextureMod    Texture // suffix
28629                         Shaded           bool
28630                         ShowOnMinimap    bool
28631                         NametagBG        color.NRGBA
28632                 }))(obj)).Visual))[:])
28633                 chk(err)
28634         }
28635         for local331 := range (*(*(struct {
28636                 MaxHP            uint16 // Player only.
28637                 CollideWithNodes bool
28638                 Weight           float32 // deprecated
28639                 ColBox, SelBox   Box
28640                 Pointable        bool
28641                 Visual           string
28642                 VisualSize       [3]float32
28643                 Textures         []Texture
28644                 SpriteSheetSize  [2]int16 // in sprites.
28645                 SpritePos        [2]int16 // in sprite sheet.
28646                 Visible          bool
28647                 MakeFootstepSnds bool
28648                 RotateSpeed      float32 // in radians per second.
28649                 Mesh             string
28650                 Colors           []color.NRGBA
28651                 CollideWithAOs   bool
28652                 StepHeight       float32
28653                 FaceRotateDir    bool
28654                 FaceRotateDirOff float32 // in degrees.
28655                 BackfaceCull     bool
28656                 Nametag          string
28657                 NametagColor     color.NRGBA
28658                 FaceRotateSpeed  float32 // in degrees per second.
28659                 Infotext         string
28660                 Itemstring       string
28661                 Glow             int8
28662                 MaxBreath        uint16  // Player only.
28663                 EyeHeight        float32 // Player only.
28664                 ZoomFOV          float32 // in degrees. Player only.
28665                 UseTextureAlpha  bool
28666                 DmgTextureMod    Texture // suffix
28667                 Shaded           bool
28668                 ShowOnMinimap    bool
28669                 NametagBG        color.NRGBA
28670         }))(obj)).VisualSize {
28671                 {
28672                         x := ((*(*(struct {
28673                                 MaxHP            uint16 // Player only.
28674                                 CollideWithNodes bool
28675                                 Weight           float32 // deprecated
28676                                 ColBox, SelBox   Box
28677                                 Pointable        bool
28678                                 Visual           string
28679                                 VisualSize       [3]float32
28680                                 Textures         []Texture
28681                                 SpriteSheetSize  [2]int16 // in sprites.
28682                                 SpritePos        [2]int16 // in sprite sheet.
28683                                 Visible          bool
28684                                 MakeFootstepSnds bool
28685                                 RotateSpeed      float32 // in radians per second.
28686                                 Mesh             string
28687                                 Colors           []color.NRGBA
28688                                 CollideWithAOs   bool
28689                                 StepHeight       float32
28690                                 FaceRotateDir    bool
28691                                 FaceRotateDirOff float32 // in degrees.
28692                                 BackfaceCull     bool
28693                                 Nametag          string
28694                                 NametagColor     color.NRGBA
28695                                 FaceRotateSpeed  float32 // in degrees per second.
28696                                 Infotext         string
28697                                 Itemstring       string
28698                                 Glow             int8
28699                                 MaxBreath        uint16  // Player only.
28700                                 EyeHeight        float32 // Player only.
28701                                 ZoomFOV          float32 // in degrees. Player only.
28702                                 UseTextureAlpha  bool
28703                                 DmgTextureMod    Texture // suffix
28704                                 Shaded           bool
28705                                 ShowOnMinimap    bool
28706                                 NametagBG        color.NRGBA
28707                         }))(obj)).VisualSize)[local331]
28708                         write32(w, math.Float32bits(x))
28709                 }
28710         }
28711         if len(((*(*(struct {
28712                 MaxHP            uint16 // Player only.
28713                 CollideWithNodes bool
28714                 Weight           float32 // deprecated
28715                 ColBox, SelBox   Box
28716                 Pointable        bool
28717                 Visual           string
28718                 VisualSize       [3]float32
28719                 Textures         []Texture
28720                 SpriteSheetSize  [2]int16 // in sprites.
28721                 SpritePos        [2]int16 // in sprite sheet.
28722                 Visible          bool
28723                 MakeFootstepSnds bool
28724                 RotateSpeed      float32 // in radians per second.
28725                 Mesh             string
28726                 Colors           []color.NRGBA
28727                 CollideWithAOs   bool
28728                 StepHeight       float32
28729                 FaceRotateDir    bool
28730                 FaceRotateDirOff float32 // in degrees.
28731                 BackfaceCull     bool
28732                 Nametag          string
28733                 NametagColor     color.NRGBA
28734                 FaceRotateSpeed  float32 // in degrees per second.
28735                 Infotext         string
28736                 Itemstring       string
28737                 Glow             int8
28738                 MaxBreath        uint16  // Player only.
28739                 EyeHeight        float32 // Player only.
28740                 ZoomFOV          float32 // in degrees. Player only.
28741                 UseTextureAlpha  bool
28742                 DmgTextureMod    Texture // suffix
28743                 Shaded           bool
28744                 ShowOnMinimap    bool
28745                 NametagBG        color.NRGBA
28746         }))(obj)).Textures)) > math.MaxUint16 {
28747                 chk(ErrTooLong)
28748         }
28749         {
28750                 x := uint16(len(((*(*(struct {
28751                         MaxHP            uint16 // Player only.
28752                         CollideWithNodes bool
28753                         Weight           float32 // deprecated
28754                         ColBox, SelBox   Box
28755                         Pointable        bool
28756                         Visual           string
28757                         VisualSize       [3]float32
28758                         Textures         []Texture
28759                         SpriteSheetSize  [2]int16 // in sprites.
28760                         SpritePos        [2]int16 // in sprite sheet.
28761                         Visible          bool
28762                         MakeFootstepSnds bool
28763                         RotateSpeed      float32 // in radians per second.
28764                         Mesh             string
28765                         Colors           []color.NRGBA
28766                         CollideWithAOs   bool
28767                         StepHeight       float32
28768                         FaceRotateDir    bool
28769                         FaceRotateDirOff float32 // in degrees.
28770                         BackfaceCull     bool
28771                         Nametag          string
28772                         NametagColor     color.NRGBA
28773                         FaceRotateSpeed  float32 // in degrees per second.
28774                         Infotext         string
28775                         Itemstring       string
28776                         Glow             int8
28777                         MaxBreath        uint16  // Player only.
28778                         EyeHeight        float32 // Player only.
28779                         ZoomFOV          float32 // in degrees. Player only.
28780                         UseTextureAlpha  bool
28781                         DmgTextureMod    Texture // suffix
28782                         Shaded           bool
28783                         ShowOnMinimap    bool
28784                         NametagBG        color.NRGBA
28785                 }))(obj)).Textures)))
28786                 write16(w, uint16(x))
28787         }
28788         for local332 := range (*(*(struct {
28789                 MaxHP            uint16 // Player only.
28790                 CollideWithNodes bool
28791                 Weight           float32 // deprecated
28792                 ColBox, SelBox   Box
28793                 Pointable        bool
28794                 Visual           string
28795                 VisualSize       [3]float32
28796                 Textures         []Texture
28797                 SpriteSheetSize  [2]int16 // in sprites.
28798                 SpritePos        [2]int16 // in sprite sheet.
28799                 Visible          bool
28800                 MakeFootstepSnds bool
28801                 RotateSpeed      float32 // in radians per second.
28802                 Mesh             string
28803                 Colors           []color.NRGBA
28804                 CollideWithAOs   bool
28805                 StepHeight       float32
28806                 FaceRotateDir    bool
28807                 FaceRotateDirOff float32 // in degrees.
28808                 BackfaceCull     bool
28809                 Nametag          string
28810                 NametagColor     color.NRGBA
28811                 FaceRotateSpeed  float32 // in degrees per second.
28812                 Infotext         string
28813                 Itemstring       string
28814                 Glow             int8
28815                 MaxBreath        uint16  // Player only.
28816                 EyeHeight        float32 // Player only.
28817                 ZoomFOV          float32 // in degrees. Player only.
28818                 UseTextureAlpha  bool
28819                 DmgTextureMod    Texture // suffix
28820                 Shaded           bool
28821                 ShowOnMinimap    bool
28822                 NametagBG        color.NRGBA
28823         }))(obj)).Textures {
28824                 if err := pcall(func() {
28825                         (((*(*(struct {
28826                                 MaxHP            uint16 // Player only.
28827                                 CollideWithNodes bool
28828                                 Weight           float32 // deprecated
28829                                 ColBox, SelBox   Box
28830                                 Pointable        bool
28831                                 Visual           string
28832                                 VisualSize       [3]float32
28833                                 Textures         []Texture
28834                                 SpriteSheetSize  [2]int16 // in sprites.
28835                                 SpritePos        [2]int16 // in sprite sheet.
28836                                 Visible          bool
28837                                 MakeFootstepSnds bool
28838                                 RotateSpeed      float32 // in radians per second.
28839                                 Mesh             string
28840                                 Colors           []color.NRGBA
28841                                 CollideWithAOs   bool
28842                                 StepHeight       float32
28843                                 FaceRotateDir    bool
28844                                 FaceRotateDirOff float32 // in degrees.
28845                                 BackfaceCull     bool
28846                                 Nametag          string
28847                                 NametagColor     color.NRGBA
28848                                 FaceRotateSpeed  float32 // in degrees per second.
28849                                 Infotext         string
28850                                 Itemstring       string
28851                                 Glow             int8
28852                                 MaxBreath        uint16  // Player only.
28853                                 EyeHeight        float32 // Player only.
28854                                 ZoomFOV          float32 // in degrees. Player only.
28855                                 UseTextureAlpha  bool
28856                                 DmgTextureMod    Texture // suffix
28857                                 Shaded           bool
28858                                 ShowOnMinimap    bool
28859                                 NametagBG        color.NRGBA
28860                         }))(obj)).Textures)[local332]).serialize(w)
28861                 }); err != nil {
28862                         if err == io.EOF {
28863                                 chk(io.EOF)
28864                         }
28865                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
28866                 }
28867         }
28868         for local333 := range (*(*(struct {
28869                 MaxHP            uint16 // Player only.
28870                 CollideWithNodes bool
28871                 Weight           float32 // deprecated
28872                 ColBox, SelBox   Box
28873                 Pointable        bool
28874                 Visual           string
28875                 VisualSize       [3]float32
28876                 Textures         []Texture
28877                 SpriteSheetSize  [2]int16 // in sprites.
28878                 SpritePos        [2]int16 // in sprite sheet.
28879                 Visible          bool
28880                 MakeFootstepSnds bool
28881                 RotateSpeed      float32 // in radians per second.
28882                 Mesh             string
28883                 Colors           []color.NRGBA
28884                 CollideWithAOs   bool
28885                 StepHeight       float32
28886                 FaceRotateDir    bool
28887                 FaceRotateDirOff float32 // in degrees.
28888                 BackfaceCull     bool
28889                 Nametag          string
28890                 NametagColor     color.NRGBA
28891                 FaceRotateSpeed  float32 // in degrees per second.
28892                 Infotext         string
28893                 Itemstring       string
28894                 Glow             int8
28895                 MaxBreath        uint16  // Player only.
28896                 EyeHeight        float32 // Player only.
28897                 ZoomFOV          float32 // in degrees. Player only.
28898                 UseTextureAlpha  bool
28899                 DmgTextureMod    Texture // suffix
28900                 Shaded           bool
28901                 ShowOnMinimap    bool
28902                 NametagBG        color.NRGBA
28903         }))(obj)).SpriteSheetSize {
28904                 {
28905                         x := ((*(*(struct {
28906                                 MaxHP            uint16 // Player only.
28907                                 CollideWithNodes bool
28908                                 Weight           float32 // deprecated
28909                                 ColBox, SelBox   Box
28910                                 Pointable        bool
28911                                 Visual           string
28912                                 VisualSize       [3]float32
28913                                 Textures         []Texture
28914                                 SpriteSheetSize  [2]int16 // in sprites.
28915                                 SpritePos        [2]int16 // in sprite sheet.
28916                                 Visible          bool
28917                                 MakeFootstepSnds bool
28918                                 RotateSpeed      float32 // in radians per second.
28919                                 Mesh             string
28920                                 Colors           []color.NRGBA
28921                                 CollideWithAOs   bool
28922                                 StepHeight       float32
28923                                 FaceRotateDir    bool
28924                                 FaceRotateDirOff float32 // in degrees.
28925                                 BackfaceCull     bool
28926                                 Nametag          string
28927                                 NametagColor     color.NRGBA
28928                                 FaceRotateSpeed  float32 // in degrees per second.
28929                                 Infotext         string
28930                                 Itemstring       string
28931                                 Glow             int8
28932                                 MaxBreath        uint16  // Player only.
28933                                 EyeHeight        float32 // Player only.
28934                                 ZoomFOV          float32 // in degrees. Player only.
28935                                 UseTextureAlpha  bool
28936                                 DmgTextureMod    Texture // suffix
28937                                 Shaded           bool
28938                                 ShowOnMinimap    bool
28939                                 NametagBG        color.NRGBA
28940                         }))(obj)).SpriteSheetSize)[local333]
28941                         write16(w, uint16(x))
28942                 }
28943         }
28944         for local334 := range (*(*(struct {
28945                 MaxHP            uint16 // Player only.
28946                 CollideWithNodes bool
28947                 Weight           float32 // deprecated
28948                 ColBox, SelBox   Box
28949                 Pointable        bool
28950                 Visual           string
28951                 VisualSize       [3]float32
28952                 Textures         []Texture
28953                 SpriteSheetSize  [2]int16 // in sprites.
28954                 SpritePos        [2]int16 // in sprite sheet.
28955                 Visible          bool
28956                 MakeFootstepSnds bool
28957                 RotateSpeed      float32 // in radians per second.
28958                 Mesh             string
28959                 Colors           []color.NRGBA
28960                 CollideWithAOs   bool
28961                 StepHeight       float32
28962                 FaceRotateDir    bool
28963                 FaceRotateDirOff float32 // in degrees.
28964                 BackfaceCull     bool
28965                 Nametag          string
28966                 NametagColor     color.NRGBA
28967                 FaceRotateSpeed  float32 // in degrees per second.
28968                 Infotext         string
28969                 Itemstring       string
28970                 Glow             int8
28971                 MaxBreath        uint16  // Player only.
28972                 EyeHeight        float32 // Player only.
28973                 ZoomFOV          float32 // in degrees. Player only.
28974                 UseTextureAlpha  bool
28975                 DmgTextureMod    Texture // suffix
28976                 Shaded           bool
28977                 ShowOnMinimap    bool
28978                 NametagBG        color.NRGBA
28979         }))(obj)).SpritePos {
28980                 {
28981                         x := ((*(*(struct {
28982                                 MaxHP            uint16 // Player only.
28983                                 CollideWithNodes bool
28984                                 Weight           float32 // deprecated
28985                                 ColBox, SelBox   Box
28986                                 Pointable        bool
28987                                 Visual           string
28988                                 VisualSize       [3]float32
28989                                 Textures         []Texture
28990                                 SpriteSheetSize  [2]int16 // in sprites.
28991                                 SpritePos        [2]int16 // in sprite sheet.
28992                                 Visible          bool
28993                                 MakeFootstepSnds bool
28994                                 RotateSpeed      float32 // in radians per second.
28995                                 Mesh             string
28996                                 Colors           []color.NRGBA
28997                                 CollideWithAOs   bool
28998                                 StepHeight       float32
28999                                 FaceRotateDir    bool
29000                                 FaceRotateDirOff float32 // in degrees.
29001                                 BackfaceCull     bool
29002                                 Nametag          string
29003                                 NametagColor     color.NRGBA
29004                                 FaceRotateSpeed  float32 // in degrees per second.
29005                                 Infotext         string
29006                                 Itemstring       string
29007                                 Glow             int8
29008                                 MaxBreath        uint16  // Player only.
29009                                 EyeHeight        float32 // Player only.
29010                                 ZoomFOV          float32 // in degrees. Player only.
29011                                 UseTextureAlpha  bool
29012                                 DmgTextureMod    Texture // suffix
29013                                 Shaded           bool
29014                                 ShowOnMinimap    bool
29015                                 NametagBG        color.NRGBA
29016                         }))(obj)).SpritePos)[local334]
29017                         write16(w, uint16(x))
29018                 }
29019         }
29020         {
29021                 x := (*(*(struct {
29022                         MaxHP            uint16 // Player only.
29023                         CollideWithNodes bool
29024                         Weight           float32 // deprecated
29025                         ColBox, SelBox   Box
29026                         Pointable        bool
29027                         Visual           string
29028                         VisualSize       [3]float32
29029                         Textures         []Texture
29030                         SpriteSheetSize  [2]int16 // in sprites.
29031                         SpritePos        [2]int16 // in sprite sheet.
29032                         Visible          bool
29033                         MakeFootstepSnds bool
29034                         RotateSpeed      float32 // in radians per second.
29035                         Mesh             string
29036                         Colors           []color.NRGBA
29037                         CollideWithAOs   bool
29038                         StepHeight       float32
29039                         FaceRotateDir    bool
29040                         FaceRotateDirOff float32 // in degrees.
29041                         BackfaceCull     bool
29042                         Nametag          string
29043                         NametagColor     color.NRGBA
29044                         FaceRotateSpeed  float32 // in degrees per second.
29045                         Infotext         string
29046                         Itemstring       string
29047                         Glow             int8
29048                         MaxBreath        uint16  // Player only.
29049                         EyeHeight        float32 // Player only.
29050                         ZoomFOV          float32 // in degrees. Player only.
29051                         UseTextureAlpha  bool
29052                         DmgTextureMod    Texture // suffix
29053                         Shaded           bool
29054                         ShowOnMinimap    bool
29055                         NametagBG        color.NRGBA
29056                 }))(obj)).Visible
29057                 if x {
29058                         write8(w, 1)
29059                 } else {
29060                         write8(w, 0)
29061                 }
29062         }
29063         {
29064                 x := (*(*(struct {
29065                         MaxHP            uint16 // Player only.
29066                         CollideWithNodes bool
29067                         Weight           float32 // deprecated
29068                         ColBox, SelBox   Box
29069                         Pointable        bool
29070                         Visual           string
29071                         VisualSize       [3]float32
29072                         Textures         []Texture
29073                         SpriteSheetSize  [2]int16 // in sprites.
29074                         SpritePos        [2]int16 // in sprite sheet.
29075                         Visible          bool
29076                         MakeFootstepSnds bool
29077                         RotateSpeed      float32 // in radians per second.
29078                         Mesh             string
29079                         Colors           []color.NRGBA
29080                         CollideWithAOs   bool
29081                         StepHeight       float32
29082                         FaceRotateDir    bool
29083                         FaceRotateDirOff float32 // in degrees.
29084                         BackfaceCull     bool
29085                         Nametag          string
29086                         NametagColor     color.NRGBA
29087                         FaceRotateSpeed  float32 // in degrees per second.
29088                         Infotext         string
29089                         Itemstring       string
29090                         Glow             int8
29091                         MaxBreath        uint16  // Player only.
29092                         EyeHeight        float32 // Player only.
29093                         ZoomFOV          float32 // in degrees. Player only.
29094                         UseTextureAlpha  bool
29095                         DmgTextureMod    Texture // suffix
29096                         Shaded           bool
29097                         ShowOnMinimap    bool
29098                         NametagBG        color.NRGBA
29099                 }))(obj)).MakeFootstepSnds
29100                 if x {
29101                         write8(w, 1)
29102                 } else {
29103                         write8(w, 0)
29104                 }
29105         }
29106         {
29107                 x := (*(*(struct {
29108                         MaxHP            uint16 // Player only.
29109                         CollideWithNodes bool
29110                         Weight           float32 // deprecated
29111                         ColBox, SelBox   Box
29112                         Pointable        bool
29113                         Visual           string
29114                         VisualSize       [3]float32
29115                         Textures         []Texture
29116                         SpriteSheetSize  [2]int16 // in sprites.
29117                         SpritePos        [2]int16 // in sprite sheet.
29118                         Visible          bool
29119                         MakeFootstepSnds bool
29120                         RotateSpeed      float32 // in radians per second.
29121                         Mesh             string
29122                         Colors           []color.NRGBA
29123                         CollideWithAOs   bool
29124                         StepHeight       float32
29125                         FaceRotateDir    bool
29126                         FaceRotateDirOff float32 // in degrees.
29127                         BackfaceCull     bool
29128                         Nametag          string
29129                         NametagColor     color.NRGBA
29130                         FaceRotateSpeed  float32 // in degrees per second.
29131                         Infotext         string
29132                         Itemstring       string
29133                         Glow             int8
29134                         MaxBreath        uint16  // Player only.
29135                         EyeHeight        float32 // Player only.
29136                         ZoomFOV          float32 // in degrees. Player only.
29137                         UseTextureAlpha  bool
29138                         DmgTextureMod    Texture // suffix
29139                         Shaded           bool
29140                         ShowOnMinimap    bool
29141                         NametagBG        color.NRGBA
29142                 }))(obj)).RotateSpeed
29143                 write32(w, math.Float32bits(x))
29144         }
29145         if len(([]byte((*(*(struct {
29146                 MaxHP            uint16 // Player only.
29147                 CollideWithNodes bool
29148                 Weight           float32 // deprecated
29149                 ColBox, SelBox   Box
29150                 Pointable        bool
29151                 Visual           string
29152                 VisualSize       [3]float32
29153                 Textures         []Texture
29154                 SpriteSheetSize  [2]int16 // in sprites.
29155                 SpritePos        [2]int16 // in sprite sheet.
29156                 Visible          bool
29157                 MakeFootstepSnds bool
29158                 RotateSpeed      float32 // in radians per second.
29159                 Mesh             string
29160                 Colors           []color.NRGBA
29161                 CollideWithAOs   bool
29162                 StepHeight       float32
29163                 FaceRotateDir    bool
29164                 FaceRotateDirOff float32 // in degrees.
29165                 BackfaceCull     bool
29166                 Nametag          string
29167                 NametagColor     color.NRGBA
29168                 FaceRotateSpeed  float32 // in degrees per second.
29169                 Infotext         string
29170                 Itemstring       string
29171                 Glow             int8
29172                 MaxBreath        uint16  // Player only.
29173                 EyeHeight        float32 // Player only.
29174                 ZoomFOV          float32 // in degrees. Player only.
29175                 UseTextureAlpha  bool
29176                 DmgTextureMod    Texture // suffix
29177                 Shaded           bool
29178                 ShowOnMinimap    bool
29179                 NametagBG        color.NRGBA
29180         }))(obj)).Mesh))) > math.MaxUint16 {
29181                 chk(ErrTooLong)
29182         }
29183         {
29184                 x := uint16(len(([]byte((*(*(struct {
29185                         MaxHP            uint16 // Player only.
29186                         CollideWithNodes bool
29187                         Weight           float32 // deprecated
29188                         ColBox, SelBox   Box
29189                         Pointable        bool
29190                         Visual           string
29191                         VisualSize       [3]float32
29192                         Textures         []Texture
29193                         SpriteSheetSize  [2]int16 // in sprites.
29194                         SpritePos        [2]int16 // in sprite sheet.
29195                         Visible          bool
29196                         MakeFootstepSnds bool
29197                         RotateSpeed      float32 // in radians per second.
29198                         Mesh             string
29199                         Colors           []color.NRGBA
29200                         CollideWithAOs   bool
29201                         StepHeight       float32
29202                         FaceRotateDir    bool
29203                         FaceRotateDirOff float32 // in degrees.
29204                         BackfaceCull     bool
29205                         Nametag          string
29206                         NametagColor     color.NRGBA
29207                         FaceRotateSpeed  float32 // in degrees per second.
29208                         Infotext         string
29209                         Itemstring       string
29210                         Glow             int8
29211                         MaxBreath        uint16  // Player only.
29212                         EyeHeight        float32 // Player only.
29213                         ZoomFOV          float32 // in degrees. Player only.
29214                         UseTextureAlpha  bool
29215                         DmgTextureMod    Texture // suffix
29216                         Shaded           bool
29217                         ShowOnMinimap    bool
29218                         NametagBG        color.NRGBA
29219                 }))(obj)).Mesh))))
29220                 write16(w, uint16(x))
29221         }
29222         {
29223                 _, err := w.Write(([]byte((*(*(struct {
29224                         MaxHP            uint16 // Player only.
29225                         CollideWithNodes bool
29226                         Weight           float32 // deprecated
29227                         ColBox, SelBox   Box
29228                         Pointable        bool
29229                         Visual           string
29230                         VisualSize       [3]float32
29231                         Textures         []Texture
29232                         SpriteSheetSize  [2]int16 // in sprites.
29233                         SpritePos        [2]int16 // in sprite sheet.
29234                         Visible          bool
29235                         MakeFootstepSnds bool
29236                         RotateSpeed      float32 // in radians per second.
29237                         Mesh             string
29238                         Colors           []color.NRGBA
29239                         CollideWithAOs   bool
29240                         StepHeight       float32
29241                         FaceRotateDir    bool
29242                         FaceRotateDirOff float32 // in degrees.
29243                         BackfaceCull     bool
29244                         Nametag          string
29245                         NametagColor     color.NRGBA
29246                         FaceRotateSpeed  float32 // in degrees per second.
29247                         Infotext         string
29248                         Itemstring       string
29249                         Glow             int8
29250                         MaxBreath        uint16  // Player only.
29251                         EyeHeight        float32 // Player only.
29252                         ZoomFOV          float32 // in degrees. Player only.
29253                         UseTextureAlpha  bool
29254                         DmgTextureMod    Texture // suffix
29255                         Shaded           bool
29256                         ShowOnMinimap    bool
29257                         NametagBG        color.NRGBA
29258                 }))(obj)).Mesh))[:])
29259                 chk(err)
29260         }
29261         if len(((*(*(struct {
29262                 MaxHP            uint16 // Player only.
29263                 CollideWithNodes bool
29264                 Weight           float32 // deprecated
29265                 ColBox, SelBox   Box
29266                 Pointable        bool
29267                 Visual           string
29268                 VisualSize       [3]float32
29269                 Textures         []Texture
29270                 SpriteSheetSize  [2]int16 // in sprites.
29271                 SpritePos        [2]int16 // in sprite sheet.
29272                 Visible          bool
29273                 MakeFootstepSnds bool
29274                 RotateSpeed      float32 // in radians per second.
29275                 Mesh             string
29276                 Colors           []color.NRGBA
29277                 CollideWithAOs   bool
29278                 StepHeight       float32
29279                 FaceRotateDir    bool
29280                 FaceRotateDirOff float32 // in degrees.
29281                 BackfaceCull     bool
29282                 Nametag          string
29283                 NametagColor     color.NRGBA
29284                 FaceRotateSpeed  float32 // in degrees per second.
29285                 Infotext         string
29286                 Itemstring       string
29287                 Glow             int8
29288                 MaxBreath        uint16  // Player only.
29289                 EyeHeight        float32 // Player only.
29290                 ZoomFOV          float32 // in degrees. Player only.
29291                 UseTextureAlpha  bool
29292                 DmgTextureMod    Texture // suffix
29293                 Shaded           bool
29294                 ShowOnMinimap    bool
29295                 NametagBG        color.NRGBA
29296         }))(obj)).Colors)) > math.MaxUint16 {
29297                 chk(ErrTooLong)
29298         }
29299         {
29300                 x := uint16(len(((*(*(struct {
29301                         MaxHP            uint16 // Player only.
29302                         CollideWithNodes bool
29303                         Weight           float32 // deprecated
29304                         ColBox, SelBox   Box
29305                         Pointable        bool
29306                         Visual           string
29307                         VisualSize       [3]float32
29308                         Textures         []Texture
29309                         SpriteSheetSize  [2]int16 // in sprites.
29310                         SpritePos        [2]int16 // in sprite sheet.
29311                         Visible          bool
29312                         MakeFootstepSnds bool
29313                         RotateSpeed      float32 // in radians per second.
29314                         Mesh             string
29315                         Colors           []color.NRGBA
29316                         CollideWithAOs   bool
29317                         StepHeight       float32
29318                         FaceRotateDir    bool
29319                         FaceRotateDirOff float32 // in degrees.
29320                         BackfaceCull     bool
29321                         Nametag          string
29322                         NametagColor     color.NRGBA
29323                         FaceRotateSpeed  float32 // in degrees per second.
29324                         Infotext         string
29325                         Itemstring       string
29326                         Glow             int8
29327                         MaxBreath        uint16  // Player only.
29328                         EyeHeight        float32 // Player only.
29329                         ZoomFOV          float32 // in degrees. Player only.
29330                         UseTextureAlpha  bool
29331                         DmgTextureMod    Texture // suffix
29332                         Shaded           bool
29333                         ShowOnMinimap    bool
29334                         NametagBG        color.NRGBA
29335                 }))(obj)).Colors)))
29336                 write16(w, uint16(x))
29337         }
29338         for local335 := range (*(*(struct {
29339                 MaxHP            uint16 // Player only.
29340                 CollideWithNodes bool
29341                 Weight           float32 // deprecated
29342                 ColBox, SelBox   Box
29343                 Pointable        bool
29344                 Visual           string
29345                 VisualSize       [3]float32
29346                 Textures         []Texture
29347                 SpriteSheetSize  [2]int16 // in sprites.
29348                 SpritePos        [2]int16 // in sprite sheet.
29349                 Visible          bool
29350                 MakeFootstepSnds bool
29351                 RotateSpeed      float32 // in radians per second.
29352                 Mesh             string
29353                 Colors           []color.NRGBA
29354                 CollideWithAOs   bool
29355                 StepHeight       float32
29356                 FaceRotateDir    bool
29357                 FaceRotateDirOff float32 // in degrees.
29358                 BackfaceCull     bool
29359                 Nametag          string
29360                 NametagColor     color.NRGBA
29361                 FaceRotateSpeed  float32 // in degrees per second.
29362                 Infotext         string
29363                 Itemstring       string
29364                 Glow             int8
29365                 MaxBreath        uint16  // Player only.
29366                 EyeHeight        float32 // Player only.
29367                 ZoomFOV          float32 // in degrees. Player only.
29368                 UseTextureAlpha  bool
29369                 DmgTextureMod    Texture // suffix
29370                 Shaded           bool
29371                 ShowOnMinimap    bool
29372                 NametagBG        color.NRGBA
29373         }))(obj)).Colors {
29374                 {
29375                         x := ((*(*(struct {
29376                                 MaxHP            uint16 // Player only.
29377                                 CollideWithNodes bool
29378                                 Weight           float32 // deprecated
29379                                 ColBox, SelBox   Box
29380                                 Pointable        bool
29381                                 Visual           string
29382                                 VisualSize       [3]float32
29383                                 Textures         []Texture
29384                                 SpriteSheetSize  [2]int16 // in sprites.
29385                                 SpritePos        [2]int16 // in sprite sheet.
29386                                 Visible          bool
29387                                 MakeFootstepSnds bool
29388                                 RotateSpeed      float32 // in radians per second.
29389                                 Mesh             string
29390                                 Colors           []color.NRGBA
29391                                 CollideWithAOs   bool
29392                                 StepHeight       float32
29393                                 FaceRotateDir    bool
29394                                 FaceRotateDirOff float32 // in degrees.
29395                                 BackfaceCull     bool
29396                                 Nametag          string
29397                                 NametagColor     color.NRGBA
29398                                 FaceRotateSpeed  float32 // in degrees per second.
29399                                 Infotext         string
29400                                 Itemstring       string
29401                                 Glow             int8
29402                                 MaxBreath        uint16  // Player only.
29403                                 EyeHeight        float32 // Player only.
29404                                 ZoomFOV          float32 // in degrees. Player only.
29405                                 UseTextureAlpha  bool
29406                                 DmgTextureMod    Texture // suffix
29407                                 Shaded           bool
29408                                 ShowOnMinimap    bool
29409                                 NametagBG        color.NRGBA
29410                         }))(obj)).Colors)[local335]
29411                         w.Write([]byte{x.A, x.R, x.G, x.B})
29412                 }
29413         }
29414         {
29415                 x := (*(*(struct {
29416                         MaxHP            uint16 // Player only.
29417                         CollideWithNodes bool
29418                         Weight           float32 // deprecated
29419                         ColBox, SelBox   Box
29420                         Pointable        bool
29421                         Visual           string
29422                         VisualSize       [3]float32
29423                         Textures         []Texture
29424                         SpriteSheetSize  [2]int16 // in sprites.
29425                         SpritePos        [2]int16 // in sprite sheet.
29426                         Visible          bool
29427                         MakeFootstepSnds bool
29428                         RotateSpeed      float32 // in radians per second.
29429                         Mesh             string
29430                         Colors           []color.NRGBA
29431                         CollideWithAOs   bool
29432                         StepHeight       float32
29433                         FaceRotateDir    bool
29434                         FaceRotateDirOff float32 // in degrees.
29435                         BackfaceCull     bool
29436                         Nametag          string
29437                         NametagColor     color.NRGBA
29438                         FaceRotateSpeed  float32 // in degrees per second.
29439                         Infotext         string
29440                         Itemstring       string
29441                         Glow             int8
29442                         MaxBreath        uint16  // Player only.
29443                         EyeHeight        float32 // Player only.
29444                         ZoomFOV          float32 // in degrees. Player only.
29445                         UseTextureAlpha  bool
29446                         DmgTextureMod    Texture // suffix
29447                         Shaded           bool
29448                         ShowOnMinimap    bool
29449                         NametagBG        color.NRGBA
29450                 }))(obj)).CollideWithAOs
29451                 if x {
29452                         write8(w, 1)
29453                 } else {
29454                         write8(w, 0)
29455                 }
29456         }
29457         {
29458                 x := (*(*(struct {
29459                         MaxHP            uint16 // Player only.
29460                         CollideWithNodes bool
29461                         Weight           float32 // deprecated
29462                         ColBox, SelBox   Box
29463                         Pointable        bool
29464                         Visual           string
29465                         VisualSize       [3]float32
29466                         Textures         []Texture
29467                         SpriteSheetSize  [2]int16 // in sprites.
29468                         SpritePos        [2]int16 // in sprite sheet.
29469                         Visible          bool
29470                         MakeFootstepSnds bool
29471                         RotateSpeed      float32 // in radians per second.
29472                         Mesh             string
29473                         Colors           []color.NRGBA
29474                         CollideWithAOs   bool
29475                         StepHeight       float32
29476                         FaceRotateDir    bool
29477                         FaceRotateDirOff float32 // in degrees.
29478                         BackfaceCull     bool
29479                         Nametag          string
29480                         NametagColor     color.NRGBA
29481                         FaceRotateSpeed  float32 // in degrees per second.
29482                         Infotext         string
29483                         Itemstring       string
29484                         Glow             int8
29485                         MaxBreath        uint16  // Player only.
29486                         EyeHeight        float32 // Player only.
29487                         ZoomFOV          float32 // in degrees. Player only.
29488                         UseTextureAlpha  bool
29489                         DmgTextureMod    Texture // suffix
29490                         Shaded           bool
29491                         ShowOnMinimap    bool
29492                         NametagBG        color.NRGBA
29493                 }))(obj)).StepHeight
29494                 write32(w, math.Float32bits(x))
29495         }
29496         {
29497                 x := (*(*(struct {
29498                         MaxHP            uint16 // Player only.
29499                         CollideWithNodes bool
29500                         Weight           float32 // deprecated
29501                         ColBox, SelBox   Box
29502                         Pointable        bool
29503                         Visual           string
29504                         VisualSize       [3]float32
29505                         Textures         []Texture
29506                         SpriteSheetSize  [2]int16 // in sprites.
29507                         SpritePos        [2]int16 // in sprite sheet.
29508                         Visible          bool
29509                         MakeFootstepSnds bool
29510                         RotateSpeed      float32 // in radians per second.
29511                         Mesh             string
29512                         Colors           []color.NRGBA
29513                         CollideWithAOs   bool
29514                         StepHeight       float32
29515                         FaceRotateDir    bool
29516                         FaceRotateDirOff float32 // in degrees.
29517                         BackfaceCull     bool
29518                         Nametag          string
29519                         NametagColor     color.NRGBA
29520                         FaceRotateSpeed  float32 // in degrees per second.
29521                         Infotext         string
29522                         Itemstring       string
29523                         Glow             int8
29524                         MaxBreath        uint16  // Player only.
29525                         EyeHeight        float32 // Player only.
29526                         ZoomFOV          float32 // in degrees. Player only.
29527                         UseTextureAlpha  bool
29528                         DmgTextureMod    Texture // suffix
29529                         Shaded           bool
29530                         ShowOnMinimap    bool
29531                         NametagBG        color.NRGBA
29532                 }))(obj)).FaceRotateDir
29533                 if x {
29534                         write8(w, 1)
29535                 } else {
29536                         write8(w, 0)
29537                 }
29538         }
29539         {
29540                 x := (*(*(struct {
29541                         MaxHP            uint16 // Player only.
29542                         CollideWithNodes bool
29543                         Weight           float32 // deprecated
29544                         ColBox, SelBox   Box
29545                         Pointable        bool
29546                         Visual           string
29547                         VisualSize       [3]float32
29548                         Textures         []Texture
29549                         SpriteSheetSize  [2]int16 // in sprites.
29550                         SpritePos        [2]int16 // in sprite sheet.
29551                         Visible          bool
29552                         MakeFootstepSnds bool
29553                         RotateSpeed      float32 // in radians per second.
29554                         Mesh             string
29555                         Colors           []color.NRGBA
29556                         CollideWithAOs   bool
29557                         StepHeight       float32
29558                         FaceRotateDir    bool
29559                         FaceRotateDirOff float32 // in degrees.
29560                         BackfaceCull     bool
29561                         Nametag          string
29562                         NametagColor     color.NRGBA
29563                         FaceRotateSpeed  float32 // in degrees per second.
29564                         Infotext         string
29565                         Itemstring       string
29566                         Glow             int8
29567                         MaxBreath        uint16  // Player only.
29568                         EyeHeight        float32 // Player only.
29569                         ZoomFOV          float32 // in degrees. Player only.
29570                         UseTextureAlpha  bool
29571                         DmgTextureMod    Texture // suffix
29572                         Shaded           bool
29573                         ShowOnMinimap    bool
29574                         NametagBG        color.NRGBA
29575                 }))(obj)).FaceRotateDirOff
29576                 write32(w, math.Float32bits(x))
29577         }
29578         {
29579                 x := (*(*(struct {
29580                         MaxHP            uint16 // Player only.
29581                         CollideWithNodes bool
29582                         Weight           float32 // deprecated
29583                         ColBox, SelBox   Box
29584                         Pointable        bool
29585                         Visual           string
29586                         VisualSize       [3]float32
29587                         Textures         []Texture
29588                         SpriteSheetSize  [2]int16 // in sprites.
29589                         SpritePos        [2]int16 // in sprite sheet.
29590                         Visible          bool
29591                         MakeFootstepSnds bool
29592                         RotateSpeed      float32 // in radians per second.
29593                         Mesh             string
29594                         Colors           []color.NRGBA
29595                         CollideWithAOs   bool
29596                         StepHeight       float32
29597                         FaceRotateDir    bool
29598                         FaceRotateDirOff float32 // in degrees.
29599                         BackfaceCull     bool
29600                         Nametag          string
29601                         NametagColor     color.NRGBA
29602                         FaceRotateSpeed  float32 // in degrees per second.
29603                         Infotext         string
29604                         Itemstring       string
29605                         Glow             int8
29606                         MaxBreath        uint16  // Player only.
29607                         EyeHeight        float32 // Player only.
29608                         ZoomFOV          float32 // in degrees. Player only.
29609                         UseTextureAlpha  bool
29610                         DmgTextureMod    Texture // suffix
29611                         Shaded           bool
29612                         ShowOnMinimap    bool
29613                         NametagBG        color.NRGBA
29614                 }))(obj)).BackfaceCull
29615                 if x {
29616                         write8(w, 1)
29617                 } else {
29618                         write8(w, 0)
29619                 }
29620         }
29621         if len(([]byte((*(*(struct {
29622                 MaxHP            uint16 // Player only.
29623                 CollideWithNodes bool
29624                 Weight           float32 // deprecated
29625                 ColBox, SelBox   Box
29626                 Pointable        bool
29627                 Visual           string
29628                 VisualSize       [3]float32
29629                 Textures         []Texture
29630                 SpriteSheetSize  [2]int16 // in sprites.
29631                 SpritePos        [2]int16 // in sprite sheet.
29632                 Visible          bool
29633                 MakeFootstepSnds bool
29634                 RotateSpeed      float32 // in radians per second.
29635                 Mesh             string
29636                 Colors           []color.NRGBA
29637                 CollideWithAOs   bool
29638                 StepHeight       float32
29639                 FaceRotateDir    bool
29640                 FaceRotateDirOff float32 // in degrees.
29641                 BackfaceCull     bool
29642                 Nametag          string
29643                 NametagColor     color.NRGBA
29644                 FaceRotateSpeed  float32 // in degrees per second.
29645                 Infotext         string
29646                 Itemstring       string
29647                 Glow             int8
29648                 MaxBreath        uint16  // Player only.
29649                 EyeHeight        float32 // Player only.
29650                 ZoomFOV          float32 // in degrees. Player only.
29651                 UseTextureAlpha  bool
29652                 DmgTextureMod    Texture // suffix
29653                 Shaded           bool
29654                 ShowOnMinimap    bool
29655                 NametagBG        color.NRGBA
29656         }))(obj)).Nametag))) > math.MaxUint16 {
29657                 chk(ErrTooLong)
29658         }
29659         {
29660                 x := uint16(len(([]byte((*(*(struct {
29661                         MaxHP            uint16 // Player only.
29662                         CollideWithNodes bool
29663                         Weight           float32 // deprecated
29664                         ColBox, SelBox   Box
29665                         Pointable        bool
29666                         Visual           string
29667                         VisualSize       [3]float32
29668                         Textures         []Texture
29669                         SpriteSheetSize  [2]int16 // in sprites.
29670                         SpritePos        [2]int16 // in sprite sheet.
29671                         Visible          bool
29672                         MakeFootstepSnds bool
29673                         RotateSpeed      float32 // in radians per second.
29674                         Mesh             string
29675                         Colors           []color.NRGBA
29676                         CollideWithAOs   bool
29677                         StepHeight       float32
29678                         FaceRotateDir    bool
29679                         FaceRotateDirOff float32 // in degrees.
29680                         BackfaceCull     bool
29681                         Nametag          string
29682                         NametagColor     color.NRGBA
29683                         FaceRotateSpeed  float32 // in degrees per second.
29684                         Infotext         string
29685                         Itemstring       string
29686                         Glow             int8
29687                         MaxBreath        uint16  // Player only.
29688                         EyeHeight        float32 // Player only.
29689                         ZoomFOV          float32 // in degrees. Player only.
29690                         UseTextureAlpha  bool
29691                         DmgTextureMod    Texture // suffix
29692                         Shaded           bool
29693                         ShowOnMinimap    bool
29694                         NametagBG        color.NRGBA
29695                 }))(obj)).Nametag))))
29696                 write16(w, uint16(x))
29697         }
29698         {
29699                 _, err := w.Write(([]byte((*(*(struct {
29700                         MaxHP            uint16 // Player only.
29701                         CollideWithNodes bool
29702                         Weight           float32 // deprecated
29703                         ColBox, SelBox   Box
29704                         Pointable        bool
29705                         Visual           string
29706                         VisualSize       [3]float32
29707                         Textures         []Texture
29708                         SpriteSheetSize  [2]int16 // in sprites.
29709                         SpritePos        [2]int16 // in sprite sheet.
29710                         Visible          bool
29711                         MakeFootstepSnds bool
29712                         RotateSpeed      float32 // in radians per second.
29713                         Mesh             string
29714                         Colors           []color.NRGBA
29715                         CollideWithAOs   bool
29716                         StepHeight       float32
29717                         FaceRotateDir    bool
29718                         FaceRotateDirOff float32 // in degrees.
29719                         BackfaceCull     bool
29720                         Nametag          string
29721                         NametagColor     color.NRGBA
29722                         FaceRotateSpeed  float32 // in degrees per second.
29723                         Infotext         string
29724                         Itemstring       string
29725                         Glow             int8
29726                         MaxBreath        uint16  // Player only.
29727                         EyeHeight        float32 // Player only.
29728                         ZoomFOV          float32 // in degrees. Player only.
29729                         UseTextureAlpha  bool
29730                         DmgTextureMod    Texture // suffix
29731                         Shaded           bool
29732                         ShowOnMinimap    bool
29733                         NametagBG        color.NRGBA
29734                 }))(obj)).Nametag))[:])
29735                 chk(err)
29736         }
29737         {
29738                 x := (*(*(struct {
29739                         MaxHP            uint16 // Player only.
29740                         CollideWithNodes bool
29741                         Weight           float32 // deprecated
29742                         ColBox, SelBox   Box
29743                         Pointable        bool
29744                         Visual           string
29745                         VisualSize       [3]float32
29746                         Textures         []Texture
29747                         SpriteSheetSize  [2]int16 // in sprites.
29748                         SpritePos        [2]int16 // in sprite sheet.
29749                         Visible          bool
29750                         MakeFootstepSnds bool
29751                         RotateSpeed      float32 // in radians per second.
29752                         Mesh             string
29753                         Colors           []color.NRGBA
29754                         CollideWithAOs   bool
29755                         StepHeight       float32
29756                         FaceRotateDir    bool
29757                         FaceRotateDirOff float32 // in degrees.
29758                         BackfaceCull     bool
29759                         Nametag          string
29760                         NametagColor     color.NRGBA
29761                         FaceRotateSpeed  float32 // in degrees per second.
29762                         Infotext         string
29763                         Itemstring       string
29764                         Glow             int8
29765                         MaxBreath        uint16  // Player only.
29766                         EyeHeight        float32 // Player only.
29767                         ZoomFOV          float32 // in degrees. Player only.
29768                         UseTextureAlpha  bool
29769                         DmgTextureMod    Texture // suffix
29770                         Shaded           bool
29771                         ShowOnMinimap    bool
29772                         NametagBG        color.NRGBA
29773                 }))(obj)).NametagColor
29774                 w.Write([]byte{x.A, x.R, x.G, x.B})
29775         }
29776         {
29777                 x := (*(*(struct {
29778                         MaxHP            uint16 // Player only.
29779                         CollideWithNodes bool
29780                         Weight           float32 // deprecated
29781                         ColBox, SelBox   Box
29782                         Pointable        bool
29783                         Visual           string
29784                         VisualSize       [3]float32
29785                         Textures         []Texture
29786                         SpriteSheetSize  [2]int16 // in sprites.
29787                         SpritePos        [2]int16 // in sprite sheet.
29788                         Visible          bool
29789                         MakeFootstepSnds bool
29790                         RotateSpeed      float32 // in radians per second.
29791                         Mesh             string
29792                         Colors           []color.NRGBA
29793                         CollideWithAOs   bool
29794                         StepHeight       float32
29795                         FaceRotateDir    bool
29796                         FaceRotateDirOff float32 // in degrees.
29797                         BackfaceCull     bool
29798                         Nametag          string
29799                         NametagColor     color.NRGBA
29800                         FaceRotateSpeed  float32 // in degrees per second.
29801                         Infotext         string
29802                         Itemstring       string
29803                         Glow             int8
29804                         MaxBreath        uint16  // Player only.
29805                         EyeHeight        float32 // Player only.
29806                         ZoomFOV          float32 // in degrees. Player only.
29807                         UseTextureAlpha  bool
29808                         DmgTextureMod    Texture // suffix
29809                         Shaded           bool
29810                         ShowOnMinimap    bool
29811                         NametagBG        color.NRGBA
29812                 }))(obj)).FaceRotateSpeed
29813                 write32(w, math.Float32bits(x))
29814         }
29815         if len(([]byte((*(*(struct {
29816                 MaxHP            uint16 // Player only.
29817                 CollideWithNodes bool
29818                 Weight           float32 // deprecated
29819                 ColBox, SelBox   Box
29820                 Pointable        bool
29821                 Visual           string
29822                 VisualSize       [3]float32
29823                 Textures         []Texture
29824                 SpriteSheetSize  [2]int16 // in sprites.
29825                 SpritePos        [2]int16 // in sprite sheet.
29826                 Visible          bool
29827                 MakeFootstepSnds bool
29828                 RotateSpeed      float32 // in radians per second.
29829                 Mesh             string
29830                 Colors           []color.NRGBA
29831                 CollideWithAOs   bool
29832                 StepHeight       float32
29833                 FaceRotateDir    bool
29834                 FaceRotateDirOff float32 // in degrees.
29835                 BackfaceCull     bool
29836                 Nametag          string
29837                 NametagColor     color.NRGBA
29838                 FaceRotateSpeed  float32 // in degrees per second.
29839                 Infotext         string
29840                 Itemstring       string
29841                 Glow             int8
29842                 MaxBreath        uint16  // Player only.
29843                 EyeHeight        float32 // Player only.
29844                 ZoomFOV          float32 // in degrees. Player only.
29845                 UseTextureAlpha  bool
29846                 DmgTextureMod    Texture // suffix
29847                 Shaded           bool
29848                 ShowOnMinimap    bool
29849                 NametagBG        color.NRGBA
29850         }))(obj)).Infotext))) > math.MaxUint16 {
29851                 chk(ErrTooLong)
29852         }
29853         {
29854                 x := uint16(len(([]byte((*(*(struct {
29855                         MaxHP            uint16 // Player only.
29856                         CollideWithNodes bool
29857                         Weight           float32 // deprecated
29858                         ColBox, SelBox   Box
29859                         Pointable        bool
29860                         Visual           string
29861                         VisualSize       [3]float32
29862                         Textures         []Texture
29863                         SpriteSheetSize  [2]int16 // in sprites.
29864                         SpritePos        [2]int16 // in sprite sheet.
29865                         Visible          bool
29866                         MakeFootstepSnds bool
29867                         RotateSpeed      float32 // in radians per second.
29868                         Mesh             string
29869                         Colors           []color.NRGBA
29870                         CollideWithAOs   bool
29871                         StepHeight       float32
29872                         FaceRotateDir    bool
29873                         FaceRotateDirOff float32 // in degrees.
29874                         BackfaceCull     bool
29875                         Nametag          string
29876                         NametagColor     color.NRGBA
29877                         FaceRotateSpeed  float32 // in degrees per second.
29878                         Infotext         string
29879                         Itemstring       string
29880                         Glow             int8
29881                         MaxBreath        uint16  // Player only.
29882                         EyeHeight        float32 // Player only.
29883                         ZoomFOV          float32 // in degrees. Player only.
29884                         UseTextureAlpha  bool
29885                         DmgTextureMod    Texture // suffix
29886                         Shaded           bool
29887                         ShowOnMinimap    bool
29888                         NametagBG        color.NRGBA
29889                 }))(obj)).Infotext))))
29890                 write16(w, uint16(x))
29891         }
29892         {
29893                 _, err := w.Write(([]byte((*(*(struct {
29894                         MaxHP            uint16 // Player only.
29895                         CollideWithNodes bool
29896                         Weight           float32 // deprecated
29897                         ColBox, SelBox   Box
29898                         Pointable        bool
29899                         Visual           string
29900                         VisualSize       [3]float32
29901                         Textures         []Texture
29902                         SpriteSheetSize  [2]int16 // in sprites.
29903                         SpritePos        [2]int16 // in sprite sheet.
29904                         Visible          bool
29905                         MakeFootstepSnds bool
29906                         RotateSpeed      float32 // in radians per second.
29907                         Mesh             string
29908                         Colors           []color.NRGBA
29909                         CollideWithAOs   bool
29910                         StepHeight       float32
29911                         FaceRotateDir    bool
29912                         FaceRotateDirOff float32 // in degrees.
29913                         BackfaceCull     bool
29914                         Nametag          string
29915                         NametagColor     color.NRGBA
29916                         FaceRotateSpeed  float32 // in degrees per second.
29917                         Infotext         string
29918                         Itemstring       string
29919                         Glow             int8
29920                         MaxBreath        uint16  // Player only.
29921                         EyeHeight        float32 // Player only.
29922                         ZoomFOV          float32 // in degrees. Player only.
29923                         UseTextureAlpha  bool
29924                         DmgTextureMod    Texture // suffix
29925                         Shaded           bool
29926                         ShowOnMinimap    bool
29927                         NametagBG        color.NRGBA
29928                 }))(obj)).Infotext))[:])
29929                 chk(err)
29930         }
29931         if len(([]byte((*(*(struct {
29932                 MaxHP            uint16 // Player only.
29933                 CollideWithNodes bool
29934                 Weight           float32 // deprecated
29935                 ColBox, SelBox   Box
29936                 Pointable        bool
29937                 Visual           string
29938                 VisualSize       [3]float32
29939                 Textures         []Texture
29940                 SpriteSheetSize  [2]int16 // in sprites.
29941                 SpritePos        [2]int16 // in sprite sheet.
29942                 Visible          bool
29943                 MakeFootstepSnds bool
29944                 RotateSpeed      float32 // in radians per second.
29945                 Mesh             string
29946                 Colors           []color.NRGBA
29947                 CollideWithAOs   bool
29948                 StepHeight       float32
29949                 FaceRotateDir    bool
29950                 FaceRotateDirOff float32 // in degrees.
29951                 BackfaceCull     bool
29952                 Nametag          string
29953                 NametagColor     color.NRGBA
29954                 FaceRotateSpeed  float32 // in degrees per second.
29955                 Infotext         string
29956                 Itemstring       string
29957                 Glow             int8
29958                 MaxBreath        uint16  // Player only.
29959                 EyeHeight        float32 // Player only.
29960                 ZoomFOV          float32 // in degrees. Player only.
29961                 UseTextureAlpha  bool
29962                 DmgTextureMod    Texture // suffix
29963                 Shaded           bool
29964                 ShowOnMinimap    bool
29965                 NametagBG        color.NRGBA
29966         }))(obj)).Itemstring))) > math.MaxUint16 {
29967                 chk(ErrTooLong)
29968         }
29969         {
29970                 x := uint16(len(([]byte((*(*(struct {
29971                         MaxHP            uint16 // Player only.
29972                         CollideWithNodes bool
29973                         Weight           float32 // deprecated
29974                         ColBox, SelBox   Box
29975                         Pointable        bool
29976                         Visual           string
29977                         VisualSize       [3]float32
29978                         Textures         []Texture
29979                         SpriteSheetSize  [2]int16 // in sprites.
29980                         SpritePos        [2]int16 // in sprite sheet.
29981                         Visible          bool
29982                         MakeFootstepSnds bool
29983                         RotateSpeed      float32 // in radians per second.
29984                         Mesh             string
29985                         Colors           []color.NRGBA
29986                         CollideWithAOs   bool
29987                         StepHeight       float32
29988                         FaceRotateDir    bool
29989                         FaceRotateDirOff float32 // in degrees.
29990                         BackfaceCull     bool
29991                         Nametag          string
29992                         NametagColor     color.NRGBA
29993                         FaceRotateSpeed  float32 // in degrees per second.
29994                         Infotext         string
29995                         Itemstring       string
29996                         Glow             int8
29997                         MaxBreath        uint16  // Player only.
29998                         EyeHeight        float32 // Player only.
29999                         ZoomFOV          float32 // in degrees. Player only.
30000                         UseTextureAlpha  bool
30001                         DmgTextureMod    Texture // suffix
30002                         Shaded           bool
30003                         ShowOnMinimap    bool
30004                         NametagBG        color.NRGBA
30005                 }))(obj)).Itemstring))))
30006                 write16(w, uint16(x))
30007         }
30008         {
30009                 _, err := w.Write(([]byte((*(*(struct {
30010                         MaxHP            uint16 // Player only.
30011                         CollideWithNodes bool
30012                         Weight           float32 // deprecated
30013                         ColBox, SelBox   Box
30014                         Pointable        bool
30015                         Visual           string
30016                         VisualSize       [3]float32
30017                         Textures         []Texture
30018                         SpriteSheetSize  [2]int16 // in sprites.
30019                         SpritePos        [2]int16 // in sprite sheet.
30020                         Visible          bool
30021                         MakeFootstepSnds bool
30022                         RotateSpeed      float32 // in radians per second.
30023                         Mesh             string
30024                         Colors           []color.NRGBA
30025                         CollideWithAOs   bool
30026                         StepHeight       float32
30027                         FaceRotateDir    bool
30028                         FaceRotateDirOff float32 // in degrees.
30029                         BackfaceCull     bool
30030                         Nametag          string
30031                         NametagColor     color.NRGBA
30032                         FaceRotateSpeed  float32 // in degrees per second.
30033                         Infotext         string
30034                         Itemstring       string
30035                         Glow             int8
30036                         MaxBreath        uint16  // Player only.
30037                         EyeHeight        float32 // Player only.
30038                         ZoomFOV          float32 // in degrees. Player only.
30039                         UseTextureAlpha  bool
30040                         DmgTextureMod    Texture // suffix
30041                         Shaded           bool
30042                         ShowOnMinimap    bool
30043                         NametagBG        color.NRGBA
30044                 }))(obj)).Itemstring))[:])
30045                 chk(err)
30046         }
30047         {
30048                 x := (*(*(struct {
30049                         MaxHP            uint16 // Player only.
30050                         CollideWithNodes bool
30051                         Weight           float32 // deprecated
30052                         ColBox, SelBox   Box
30053                         Pointable        bool
30054                         Visual           string
30055                         VisualSize       [3]float32
30056                         Textures         []Texture
30057                         SpriteSheetSize  [2]int16 // in sprites.
30058                         SpritePos        [2]int16 // in sprite sheet.
30059                         Visible          bool
30060                         MakeFootstepSnds bool
30061                         RotateSpeed      float32 // in radians per second.
30062                         Mesh             string
30063                         Colors           []color.NRGBA
30064                         CollideWithAOs   bool
30065                         StepHeight       float32
30066                         FaceRotateDir    bool
30067                         FaceRotateDirOff float32 // in degrees.
30068                         BackfaceCull     bool
30069                         Nametag          string
30070                         NametagColor     color.NRGBA
30071                         FaceRotateSpeed  float32 // in degrees per second.
30072                         Infotext         string
30073                         Itemstring       string
30074                         Glow             int8
30075                         MaxBreath        uint16  // Player only.
30076                         EyeHeight        float32 // Player only.
30077                         ZoomFOV          float32 // in degrees. Player only.
30078                         UseTextureAlpha  bool
30079                         DmgTextureMod    Texture // suffix
30080                         Shaded           bool
30081                         ShowOnMinimap    bool
30082                         NametagBG        color.NRGBA
30083                 }))(obj)).Glow
30084                 write8(w, uint8(x))
30085         }
30086         {
30087                 x := (*(*(struct {
30088                         MaxHP            uint16 // Player only.
30089                         CollideWithNodes bool
30090                         Weight           float32 // deprecated
30091                         ColBox, SelBox   Box
30092                         Pointable        bool
30093                         Visual           string
30094                         VisualSize       [3]float32
30095                         Textures         []Texture
30096                         SpriteSheetSize  [2]int16 // in sprites.
30097                         SpritePos        [2]int16 // in sprite sheet.
30098                         Visible          bool
30099                         MakeFootstepSnds bool
30100                         RotateSpeed      float32 // in radians per second.
30101                         Mesh             string
30102                         Colors           []color.NRGBA
30103                         CollideWithAOs   bool
30104                         StepHeight       float32
30105                         FaceRotateDir    bool
30106                         FaceRotateDirOff float32 // in degrees.
30107                         BackfaceCull     bool
30108                         Nametag          string
30109                         NametagColor     color.NRGBA
30110                         FaceRotateSpeed  float32 // in degrees per second.
30111                         Infotext         string
30112                         Itemstring       string
30113                         Glow             int8
30114                         MaxBreath        uint16  // Player only.
30115                         EyeHeight        float32 // Player only.
30116                         ZoomFOV          float32 // in degrees. Player only.
30117                         UseTextureAlpha  bool
30118                         DmgTextureMod    Texture // suffix
30119                         Shaded           bool
30120                         ShowOnMinimap    bool
30121                         NametagBG        color.NRGBA
30122                 }))(obj)).MaxBreath
30123                 write16(w, uint16(x))
30124         }
30125         {
30126                 x := (*(*(struct {
30127                         MaxHP            uint16 // Player only.
30128                         CollideWithNodes bool
30129                         Weight           float32 // deprecated
30130                         ColBox, SelBox   Box
30131                         Pointable        bool
30132                         Visual           string
30133                         VisualSize       [3]float32
30134                         Textures         []Texture
30135                         SpriteSheetSize  [2]int16 // in sprites.
30136                         SpritePos        [2]int16 // in sprite sheet.
30137                         Visible          bool
30138                         MakeFootstepSnds bool
30139                         RotateSpeed      float32 // in radians per second.
30140                         Mesh             string
30141                         Colors           []color.NRGBA
30142                         CollideWithAOs   bool
30143                         StepHeight       float32
30144                         FaceRotateDir    bool
30145                         FaceRotateDirOff float32 // in degrees.
30146                         BackfaceCull     bool
30147                         Nametag          string
30148                         NametagColor     color.NRGBA
30149                         FaceRotateSpeed  float32 // in degrees per second.
30150                         Infotext         string
30151                         Itemstring       string
30152                         Glow             int8
30153                         MaxBreath        uint16  // Player only.
30154                         EyeHeight        float32 // Player only.
30155                         ZoomFOV          float32 // in degrees. Player only.
30156                         UseTextureAlpha  bool
30157                         DmgTextureMod    Texture // suffix
30158                         Shaded           bool
30159                         ShowOnMinimap    bool
30160                         NametagBG        color.NRGBA
30161                 }))(obj)).EyeHeight
30162                 write32(w, math.Float32bits(x))
30163         }
30164         {
30165                 x := (*(*(struct {
30166                         MaxHP            uint16 // Player only.
30167                         CollideWithNodes bool
30168                         Weight           float32 // deprecated
30169                         ColBox, SelBox   Box
30170                         Pointable        bool
30171                         Visual           string
30172                         VisualSize       [3]float32
30173                         Textures         []Texture
30174                         SpriteSheetSize  [2]int16 // in sprites.
30175                         SpritePos        [2]int16 // in sprite sheet.
30176                         Visible          bool
30177                         MakeFootstepSnds bool
30178                         RotateSpeed      float32 // in radians per second.
30179                         Mesh             string
30180                         Colors           []color.NRGBA
30181                         CollideWithAOs   bool
30182                         StepHeight       float32
30183                         FaceRotateDir    bool
30184                         FaceRotateDirOff float32 // in degrees.
30185                         BackfaceCull     bool
30186                         Nametag          string
30187                         NametagColor     color.NRGBA
30188                         FaceRotateSpeed  float32 // in degrees per second.
30189                         Infotext         string
30190                         Itemstring       string
30191                         Glow             int8
30192                         MaxBreath        uint16  // Player only.
30193                         EyeHeight        float32 // Player only.
30194                         ZoomFOV          float32 // in degrees. Player only.
30195                         UseTextureAlpha  bool
30196                         DmgTextureMod    Texture // suffix
30197                         Shaded           bool
30198                         ShowOnMinimap    bool
30199                         NametagBG        color.NRGBA
30200                 }))(obj)).ZoomFOV
30201                 write32(w, math.Float32bits(x))
30202         }
30203         {
30204                 x := (*(*(struct {
30205                         MaxHP            uint16 // Player only.
30206                         CollideWithNodes bool
30207                         Weight           float32 // deprecated
30208                         ColBox, SelBox   Box
30209                         Pointable        bool
30210                         Visual           string
30211                         VisualSize       [3]float32
30212                         Textures         []Texture
30213                         SpriteSheetSize  [2]int16 // in sprites.
30214                         SpritePos        [2]int16 // in sprite sheet.
30215                         Visible          bool
30216                         MakeFootstepSnds bool
30217                         RotateSpeed      float32 // in radians per second.
30218                         Mesh             string
30219                         Colors           []color.NRGBA
30220                         CollideWithAOs   bool
30221                         StepHeight       float32
30222                         FaceRotateDir    bool
30223                         FaceRotateDirOff float32 // in degrees.
30224                         BackfaceCull     bool
30225                         Nametag          string
30226                         NametagColor     color.NRGBA
30227                         FaceRotateSpeed  float32 // in degrees per second.
30228                         Infotext         string
30229                         Itemstring       string
30230                         Glow             int8
30231                         MaxBreath        uint16  // Player only.
30232                         EyeHeight        float32 // Player only.
30233                         ZoomFOV          float32 // in degrees. Player only.
30234                         UseTextureAlpha  bool
30235                         DmgTextureMod    Texture // suffix
30236                         Shaded           bool
30237                         ShowOnMinimap    bool
30238                         NametagBG        color.NRGBA
30239                 }))(obj)).UseTextureAlpha
30240                 if x {
30241                         write8(w, 1)
30242                 } else {
30243                         write8(w, 0)
30244                 }
30245         }
30246         if err := pcall(func() {
30247                 ((*(*(struct {
30248                         MaxHP            uint16 // Player only.
30249                         CollideWithNodes bool
30250                         Weight           float32 // deprecated
30251                         ColBox, SelBox   Box
30252                         Pointable        bool
30253                         Visual           string
30254                         VisualSize       [3]float32
30255                         Textures         []Texture
30256                         SpriteSheetSize  [2]int16 // in sprites.
30257                         SpritePos        [2]int16 // in sprite sheet.
30258                         Visible          bool
30259                         MakeFootstepSnds bool
30260                         RotateSpeed      float32 // in radians per second.
30261                         Mesh             string
30262                         Colors           []color.NRGBA
30263                         CollideWithAOs   bool
30264                         StepHeight       float32
30265                         FaceRotateDir    bool
30266                         FaceRotateDirOff float32 // in degrees.
30267                         BackfaceCull     bool
30268                         Nametag          string
30269                         NametagColor     color.NRGBA
30270                         FaceRotateSpeed  float32 // in degrees per second.
30271                         Infotext         string
30272                         Itemstring       string
30273                         Glow             int8
30274                         MaxBreath        uint16  // Player only.
30275                         EyeHeight        float32 // Player only.
30276                         ZoomFOV          float32 // in degrees. Player only.
30277                         UseTextureAlpha  bool
30278                         DmgTextureMod    Texture // suffix
30279                         Shaded           bool
30280                         ShowOnMinimap    bool
30281                         NametagBG        color.NRGBA
30282                 }))(obj)).DmgTextureMod).serialize(w)
30283         }); err != nil {
30284                 if err == io.EOF {
30285                         chk(io.EOF)
30286                 }
30287                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
30288         }
30289         {
30290                 x := (*(*(struct {
30291                         MaxHP            uint16 // Player only.
30292                         CollideWithNodes bool
30293                         Weight           float32 // deprecated
30294                         ColBox, SelBox   Box
30295                         Pointable        bool
30296                         Visual           string
30297                         VisualSize       [3]float32
30298                         Textures         []Texture
30299                         SpriteSheetSize  [2]int16 // in sprites.
30300                         SpritePos        [2]int16 // in sprite sheet.
30301                         Visible          bool
30302                         MakeFootstepSnds bool
30303                         RotateSpeed      float32 // in radians per second.
30304                         Mesh             string
30305                         Colors           []color.NRGBA
30306                         CollideWithAOs   bool
30307                         StepHeight       float32
30308                         FaceRotateDir    bool
30309                         FaceRotateDirOff float32 // in degrees.
30310                         BackfaceCull     bool
30311                         Nametag          string
30312                         NametagColor     color.NRGBA
30313                         FaceRotateSpeed  float32 // in degrees per second.
30314                         Infotext         string
30315                         Itemstring       string
30316                         Glow             int8
30317                         MaxBreath        uint16  // Player only.
30318                         EyeHeight        float32 // Player only.
30319                         ZoomFOV          float32 // in degrees. Player only.
30320                         UseTextureAlpha  bool
30321                         DmgTextureMod    Texture // suffix
30322                         Shaded           bool
30323                         ShowOnMinimap    bool
30324                         NametagBG        color.NRGBA
30325                 }))(obj)).Shaded
30326                 if x {
30327                         write8(w, 1)
30328                 } else {
30329                         write8(w, 0)
30330                 }
30331         }
30332         {
30333                 x := (*(*(struct {
30334                         MaxHP            uint16 // Player only.
30335                         CollideWithNodes bool
30336                         Weight           float32 // deprecated
30337                         ColBox, SelBox   Box
30338                         Pointable        bool
30339                         Visual           string
30340                         VisualSize       [3]float32
30341                         Textures         []Texture
30342                         SpriteSheetSize  [2]int16 // in sprites.
30343                         SpritePos        [2]int16 // in sprite sheet.
30344                         Visible          bool
30345                         MakeFootstepSnds bool
30346                         RotateSpeed      float32 // in radians per second.
30347                         Mesh             string
30348                         Colors           []color.NRGBA
30349                         CollideWithAOs   bool
30350                         StepHeight       float32
30351                         FaceRotateDir    bool
30352                         FaceRotateDirOff float32 // in degrees.
30353                         BackfaceCull     bool
30354                         Nametag          string
30355                         NametagColor     color.NRGBA
30356                         FaceRotateSpeed  float32 // in degrees per second.
30357                         Infotext         string
30358                         Itemstring       string
30359                         Glow             int8
30360                         MaxBreath        uint16  // Player only.
30361                         EyeHeight        float32 // Player only.
30362                         ZoomFOV          float32 // in degrees. Player only.
30363                         UseTextureAlpha  bool
30364                         DmgTextureMod    Texture // suffix
30365                         Shaded           bool
30366                         ShowOnMinimap    bool
30367                         NametagBG        color.NRGBA
30368                 }))(obj)).ShowOnMinimap
30369                 if x {
30370                         write8(w, 1)
30371                 } else {
30372                         write8(w, 0)
30373                 }
30374         }
30375         {
30376                 x := (*(*(struct {
30377                         MaxHP            uint16 // Player only.
30378                         CollideWithNodes bool
30379                         Weight           float32 // deprecated
30380                         ColBox, SelBox   Box
30381                         Pointable        bool
30382                         Visual           string
30383                         VisualSize       [3]float32
30384                         Textures         []Texture
30385                         SpriteSheetSize  [2]int16 // in sprites.
30386                         SpritePos        [2]int16 // in sprite sheet.
30387                         Visible          bool
30388                         MakeFootstepSnds bool
30389                         RotateSpeed      float32 // in radians per second.
30390                         Mesh             string
30391                         Colors           []color.NRGBA
30392                         CollideWithAOs   bool
30393                         StepHeight       float32
30394                         FaceRotateDir    bool
30395                         FaceRotateDirOff float32 // in degrees.
30396                         BackfaceCull     bool
30397                         Nametag          string
30398                         NametagColor     color.NRGBA
30399                         FaceRotateSpeed  float32 // in degrees per second.
30400                         Infotext         string
30401                         Itemstring       string
30402                         Glow             int8
30403                         MaxBreath        uint16  // Player only.
30404                         EyeHeight        float32 // Player only.
30405                         ZoomFOV          float32 // in degrees. Player only.
30406                         UseTextureAlpha  bool
30407                         DmgTextureMod    Texture // suffix
30408                         Shaded           bool
30409                         ShowOnMinimap    bool
30410                         NametagBG        color.NRGBA
30411                 }))(obj)).NametagBG
30412                 w.Write([]byte{x.A, x.R, x.G, x.B})
30413         }
30414 }
30415
30416 func (obj *AOProps) deserialize(r io.Reader) {
30417         {
30418                 var local336 uint8
30419                 local337 := uint8(4)
30420                 {
30421                         p := &local336
30422                         *p = read8(r)
30423                 }
30424                 if local336 != local337 {
30425                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local336))
30426                 }
30427         }
30428         {
30429                 p := &(*(*(struct {
30430                         MaxHP            uint16 // Player only.
30431                         CollideWithNodes bool
30432                         Weight           float32 // deprecated
30433                         ColBox, SelBox   Box
30434                         Pointable        bool
30435                         Visual           string
30436                         VisualSize       [3]float32
30437                         Textures         []Texture
30438                         SpriteSheetSize  [2]int16 // in sprites.
30439                         SpritePos        [2]int16 // in sprite sheet.
30440                         Visible          bool
30441                         MakeFootstepSnds bool
30442                         RotateSpeed      float32 // in radians per second.
30443                         Mesh             string
30444                         Colors           []color.NRGBA
30445                         CollideWithAOs   bool
30446                         StepHeight       float32
30447                         FaceRotateDir    bool
30448                         FaceRotateDirOff float32 // in degrees.
30449                         BackfaceCull     bool
30450                         Nametag          string
30451                         NametagColor     color.NRGBA
30452                         FaceRotateSpeed  float32 // in degrees per second.
30453                         Infotext         string
30454                         Itemstring       string
30455                         Glow             int8
30456                         MaxBreath        uint16  // Player only.
30457                         EyeHeight        float32 // Player only.
30458                         ZoomFOV          float32 // in degrees. Player only.
30459                         UseTextureAlpha  bool
30460                         DmgTextureMod    Texture // suffix
30461                         Shaded           bool
30462                         ShowOnMinimap    bool
30463                         NametagBG        color.NRGBA
30464                 }))(obj)).MaxHP
30465                 *p = read16(r)
30466         }
30467         {
30468                 p := &(*(*(struct {
30469                         MaxHP            uint16 // Player only.
30470                         CollideWithNodes bool
30471                         Weight           float32 // deprecated
30472                         ColBox, SelBox   Box
30473                         Pointable        bool
30474                         Visual           string
30475                         VisualSize       [3]float32
30476                         Textures         []Texture
30477                         SpriteSheetSize  [2]int16 // in sprites.
30478                         SpritePos        [2]int16 // in sprite sheet.
30479                         Visible          bool
30480                         MakeFootstepSnds bool
30481                         RotateSpeed      float32 // in radians per second.
30482                         Mesh             string
30483                         Colors           []color.NRGBA
30484                         CollideWithAOs   bool
30485                         StepHeight       float32
30486                         FaceRotateDir    bool
30487                         FaceRotateDirOff float32 // in degrees.
30488                         BackfaceCull     bool
30489                         Nametag          string
30490                         NametagColor     color.NRGBA
30491                         FaceRotateSpeed  float32 // in degrees per second.
30492                         Infotext         string
30493                         Itemstring       string
30494                         Glow             int8
30495                         MaxBreath        uint16  // Player only.
30496                         EyeHeight        float32 // Player only.
30497                         ZoomFOV          float32 // in degrees. Player only.
30498                         UseTextureAlpha  bool
30499                         DmgTextureMod    Texture // suffix
30500                         Shaded           bool
30501                         ShowOnMinimap    bool
30502                         NametagBG        color.NRGBA
30503                 }))(obj)).CollideWithNodes
30504                 switch n := read8(r); n {
30505                 case 0:
30506                         *p = false
30507                 case 1:
30508                         *p = true
30509                 default:
30510                         chk(fmt.Errorf("invalid bool: %d", n))
30511                 }
30512         }
30513         {
30514                 p := &(*(*(struct {
30515                         MaxHP            uint16 // Player only.
30516                         CollideWithNodes bool
30517                         Weight           float32 // deprecated
30518                         ColBox, SelBox   Box
30519                         Pointable        bool
30520                         Visual           string
30521                         VisualSize       [3]float32
30522                         Textures         []Texture
30523                         SpriteSheetSize  [2]int16 // in sprites.
30524                         SpritePos        [2]int16 // in sprite sheet.
30525                         Visible          bool
30526                         MakeFootstepSnds bool
30527                         RotateSpeed      float32 // in radians per second.
30528                         Mesh             string
30529                         Colors           []color.NRGBA
30530                         CollideWithAOs   bool
30531                         StepHeight       float32
30532                         FaceRotateDir    bool
30533                         FaceRotateDirOff float32 // in degrees.
30534                         BackfaceCull     bool
30535                         Nametag          string
30536                         NametagColor     color.NRGBA
30537                         FaceRotateSpeed  float32 // in degrees per second.
30538                         Infotext         string
30539                         Itemstring       string
30540                         Glow             int8
30541                         MaxBreath        uint16  // Player only.
30542                         EyeHeight        float32 // Player only.
30543                         ZoomFOV          float32 // in degrees. Player only.
30544                         UseTextureAlpha  bool
30545                         DmgTextureMod    Texture // suffix
30546                         Shaded           bool
30547                         ShowOnMinimap    bool
30548                         NametagBG        color.NRGBA
30549                 }))(obj)).Weight
30550                 *p = math.Float32frombits(read32(r))
30551         }
30552         if err := pcall(func() {
30553                 ((*(*(struct {
30554                         MaxHP            uint16 // Player only.
30555                         CollideWithNodes bool
30556                         Weight           float32 // deprecated
30557                         ColBox, SelBox   Box
30558                         Pointable        bool
30559                         Visual           string
30560                         VisualSize       [3]float32
30561                         Textures         []Texture
30562                         SpriteSheetSize  [2]int16 // in sprites.
30563                         SpritePos        [2]int16 // in sprite sheet.
30564                         Visible          bool
30565                         MakeFootstepSnds bool
30566                         RotateSpeed      float32 // in radians per second.
30567                         Mesh             string
30568                         Colors           []color.NRGBA
30569                         CollideWithAOs   bool
30570                         StepHeight       float32
30571                         FaceRotateDir    bool
30572                         FaceRotateDirOff float32 // in degrees.
30573                         BackfaceCull     bool
30574                         Nametag          string
30575                         NametagColor     color.NRGBA
30576                         FaceRotateSpeed  float32 // in degrees per second.
30577                         Infotext         string
30578                         Itemstring       string
30579                         Glow             int8
30580                         MaxBreath        uint16  // Player only.
30581                         EyeHeight        float32 // Player only.
30582                         ZoomFOV          float32 // in degrees. Player only.
30583                         UseTextureAlpha  bool
30584                         DmgTextureMod    Texture // suffix
30585                         Shaded           bool
30586                         ShowOnMinimap    bool
30587                         NametagBG        color.NRGBA
30588                 }))(obj)).ColBox).deserialize(r)
30589         }); err != nil {
30590                 if err == io.EOF {
30591                         chk(io.EOF)
30592                 }
30593                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
30594         }
30595         if err := pcall(func() {
30596                 ((*(*(struct {
30597                         MaxHP            uint16 // Player only.
30598                         CollideWithNodes bool
30599                         Weight           float32 // deprecated
30600                         ColBox, SelBox   Box
30601                         Pointable        bool
30602                         Visual           string
30603                         VisualSize       [3]float32
30604                         Textures         []Texture
30605                         SpriteSheetSize  [2]int16 // in sprites.
30606                         SpritePos        [2]int16 // in sprite sheet.
30607                         Visible          bool
30608                         MakeFootstepSnds bool
30609                         RotateSpeed      float32 // in radians per second.
30610                         Mesh             string
30611                         Colors           []color.NRGBA
30612                         CollideWithAOs   bool
30613                         StepHeight       float32
30614                         FaceRotateDir    bool
30615                         FaceRotateDirOff float32 // in degrees.
30616                         BackfaceCull     bool
30617                         Nametag          string
30618                         NametagColor     color.NRGBA
30619                         FaceRotateSpeed  float32 // in degrees per second.
30620                         Infotext         string
30621                         Itemstring       string
30622                         Glow             int8
30623                         MaxBreath        uint16  // Player only.
30624                         EyeHeight        float32 // Player only.
30625                         ZoomFOV          float32 // in degrees. Player only.
30626                         UseTextureAlpha  bool
30627                         DmgTextureMod    Texture // suffix
30628                         Shaded           bool
30629                         ShowOnMinimap    bool
30630                         NametagBG        color.NRGBA
30631                 }))(obj)).SelBox).deserialize(r)
30632         }); err != nil {
30633                 if err == io.EOF {
30634                         chk(io.EOF)
30635                 }
30636                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
30637         }
30638         {
30639                 p := &(*(*(struct {
30640                         MaxHP            uint16 // Player only.
30641                         CollideWithNodes bool
30642                         Weight           float32 // deprecated
30643                         ColBox, SelBox   Box
30644                         Pointable        bool
30645                         Visual           string
30646                         VisualSize       [3]float32
30647                         Textures         []Texture
30648                         SpriteSheetSize  [2]int16 // in sprites.
30649                         SpritePos        [2]int16 // in sprite sheet.
30650                         Visible          bool
30651                         MakeFootstepSnds bool
30652                         RotateSpeed      float32 // in radians per second.
30653                         Mesh             string
30654                         Colors           []color.NRGBA
30655                         CollideWithAOs   bool
30656                         StepHeight       float32
30657                         FaceRotateDir    bool
30658                         FaceRotateDirOff float32 // in degrees.
30659                         BackfaceCull     bool
30660                         Nametag          string
30661                         NametagColor     color.NRGBA
30662                         FaceRotateSpeed  float32 // in degrees per second.
30663                         Infotext         string
30664                         Itemstring       string
30665                         Glow             int8
30666                         MaxBreath        uint16  // Player only.
30667                         EyeHeight        float32 // Player only.
30668                         ZoomFOV          float32 // in degrees. Player only.
30669                         UseTextureAlpha  bool
30670                         DmgTextureMod    Texture // suffix
30671                         Shaded           bool
30672                         ShowOnMinimap    bool
30673                         NametagBG        color.NRGBA
30674                 }))(obj)).Pointable
30675                 switch n := read8(r); n {
30676                 case 0:
30677                         *p = false
30678                 case 1:
30679                         *p = true
30680                 default:
30681                         chk(fmt.Errorf("invalid bool: %d", n))
30682                 }
30683         }
30684         var local338 []uint8
30685         var local339 uint16
30686         {
30687                 p := &local339
30688                 *p = read16(r)
30689         }
30690         (local338) = make([]uint8, local339)
30691         {
30692                 _, err := io.ReadFull(r, (local338)[:])
30693                 chk(err)
30694         }
30695         ((*(*(struct {
30696                 MaxHP            uint16 // Player only.
30697                 CollideWithNodes bool
30698                 Weight           float32 // deprecated
30699                 ColBox, SelBox   Box
30700                 Pointable        bool
30701                 Visual           string
30702                 VisualSize       [3]float32
30703                 Textures         []Texture
30704                 SpriteSheetSize  [2]int16 // in sprites.
30705                 SpritePos        [2]int16 // in sprite sheet.
30706                 Visible          bool
30707                 MakeFootstepSnds bool
30708                 RotateSpeed      float32 // in radians per second.
30709                 Mesh             string
30710                 Colors           []color.NRGBA
30711                 CollideWithAOs   bool
30712                 StepHeight       float32
30713                 FaceRotateDir    bool
30714                 FaceRotateDirOff float32 // in degrees.
30715                 BackfaceCull     bool
30716                 Nametag          string
30717                 NametagColor     color.NRGBA
30718                 FaceRotateSpeed  float32 // in degrees per second.
30719                 Infotext         string
30720                 Itemstring       string
30721                 Glow             int8
30722                 MaxBreath        uint16  // Player only.
30723                 EyeHeight        float32 // Player only.
30724                 ZoomFOV          float32 // in degrees. Player only.
30725                 UseTextureAlpha  bool
30726                 DmgTextureMod    Texture // suffix
30727                 Shaded           bool
30728                 ShowOnMinimap    bool
30729                 NametagBG        color.NRGBA
30730         }))(obj)).Visual) = string(local338)
30731         for local340 := range (*(*(struct {
30732                 MaxHP            uint16 // Player only.
30733                 CollideWithNodes bool
30734                 Weight           float32 // deprecated
30735                 ColBox, SelBox   Box
30736                 Pointable        bool
30737                 Visual           string
30738                 VisualSize       [3]float32
30739                 Textures         []Texture
30740                 SpriteSheetSize  [2]int16 // in sprites.
30741                 SpritePos        [2]int16 // in sprite sheet.
30742                 Visible          bool
30743                 MakeFootstepSnds bool
30744                 RotateSpeed      float32 // in radians per second.
30745                 Mesh             string
30746                 Colors           []color.NRGBA
30747                 CollideWithAOs   bool
30748                 StepHeight       float32
30749                 FaceRotateDir    bool
30750                 FaceRotateDirOff float32 // in degrees.
30751                 BackfaceCull     bool
30752                 Nametag          string
30753                 NametagColor     color.NRGBA
30754                 FaceRotateSpeed  float32 // in degrees per second.
30755                 Infotext         string
30756                 Itemstring       string
30757                 Glow             int8
30758                 MaxBreath        uint16  // Player only.
30759                 EyeHeight        float32 // Player only.
30760                 ZoomFOV          float32 // in degrees. Player only.
30761                 UseTextureAlpha  bool
30762                 DmgTextureMod    Texture // suffix
30763                 Shaded           bool
30764                 ShowOnMinimap    bool
30765                 NametagBG        color.NRGBA
30766         }))(obj)).VisualSize {
30767                 {
30768                         p := &((*(*(struct {
30769                                 MaxHP            uint16 // Player only.
30770                                 CollideWithNodes bool
30771                                 Weight           float32 // deprecated
30772                                 ColBox, SelBox   Box
30773                                 Pointable        bool
30774                                 Visual           string
30775                                 VisualSize       [3]float32
30776                                 Textures         []Texture
30777                                 SpriteSheetSize  [2]int16 // in sprites.
30778                                 SpritePos        [2]int16 // in sprite sheet.
30779                                 Visible          bool
30780                                 MakeFootstepSnds bool
30781                                 RotateSpeed      float32 // in radians per second.
30782                                 Mesh             string
30783                                 Colors           []color.NRGBA
30784                                 CollideWithAOs   bool
30785                                 StepHeight       float32
30786                                 FaceRotateDir    bool
30787                                 FaceRotateDirOff float32 // in degrees.
30788                                 BackfaceCull     bool
30789                                 Nametag          string
30790                                 NametagColor     color.NRGBA
30791                                 FaceRotateSpeed  float32 // in degrees per second.
30792                                 Infotext         string
30793                                 Itemstring       string
30794                                 Glow             int8
30795                                 MaxBreath        uint16  // Player only.
30796                                 EyeHeight        float32 // Player only.
30797                                 ZoomFOV          float32 // in degrees. Player only.
30798                                 UseTextureAlpha  bool
30799                                 DmgTextureMod    Texture // suffix
30800                                 Shaded           bool
30801                                 ShowOnMinimap    bool
30802                                 NametagBG        color.NRGBA
30803                         }))(obj)).VisualSize)[local340]
30804                         *p = math.Float32frombits(read32(r))
30805                 }
30806         }
30807         var local341 uint16
30808         {
30809                 p := &local341
30810                 *p = read16(r)
30811         }
30812         ((*(*(struct {
30813                 MaxHP            uint16 // Player only.
30814                 CollideWithNodes bool
30815                 Weight           float32 // deprecated
30816                 ColBox, SelBox   Box
30817                 Pointable        bool
30818                 Visual           string
30819                 VisualSize       [3]float32
30820                 Textures         []Texture
30821                 SpriteSheetSize  [2]int16 // in sprites.
30822                 SpritePos        [2]int16 // in sprite sheet.
30823                 Visible          bool
30824                 MakeFootstepSnds bool
30825                 RotateSpeed      float32 // in radians per second.
30826                 Mesh             string
30827                 Colors           []color.NRGBA
30828                 CollideWithAOs   bool
30829                 StepHeight       float32
30830                 FaceRotateDir    bool
30831                 FaceRotateDirOff float32 // in degrees.
30832                 BackfaceCull     bool
30833                 Nametag          string
30834                 NametagColor     color.NRGBA
30835                 FaceRotateSpeed  float32 // in degrees per second.
30836                 Infotext         string
30837                 Itemstring       string
30838                 Glow             int8
30839                 MaxBreath        uint16  // Player only.
30840                 EyeHeight        float32 // Player only.
30841                 ZoomFOV          float32 // in degrees. Player only.
30842                 UseTextureAlpha  bool
30843                 DmgTextureMod    Texture // suffix
30844                 Shaded           bool
30845                 ShowOnMinimap    bool
30846                 NametagBG        color.NRGBA
30847         }))(obj)).Textures) = make([]Texture, local341)
30848         for local342 := range (*(*(struct {
30849                 MaxHP            uint16 // Player only.
30850                 CollideWithNodes bool
30851                 Weight           float32 // deprecated
30852                 ColBox, SelBox   Box
30853                 Pointable        bool
30854                 Visual           string
30855                 VisualSize       [3]float32
30856                 Textures         []Texture
30857                 SpriteSheetSize  [2]int16 // in sprites.
30858                 SpritePos        [2]int16 // in sprite sheet.
30859                 Visible          bool
30860                 MakeFootstepSnds bool
30861                 RotateSpeed      float32 // in radians per second.
30862                 Mesh             string
30863                 Colors           []color.NRGBA
30864                 CollideWithAOs   bool
30865                 StepHeight       float32
30866                 FaceRotateDir    bool
30867                 FaceRotateDirOff float32 // in degrees.
30868                 BackfaceCull     bool
30869                 Nametag          string
30870                 NametagColor     color.NRGBA
30871                 FaceRotateSpeed  float32 // in degrees per second.
30872                 Infotext         string
30873                 Itemstring       string
30874                 Glow             int8
30875                 MaxBreath        uint16  // Player only.
30876                 EyeHeight        float32 // Player only.
30877                 ZoomFOV          float32 // in degrees. Player only.
30878                 UseTextureAlpha  bool
30879                 DmgTextureMod    Texture // suffix
30880                 Shaded           bool
30881                 ShowOnMinimap    bool
30882                 NametagBG        color.NRGBA
30883         }))(obj)).Textures {
30884                 if err := pcall(func() {
30885                         (((*(*(struct {
30886                                 MaxHP            uint16 // Player only.
30887                                 CollideWithNodes bool
30888                                 Weight           float32 // deprecated
30889                                 ColBox, SelBox   Box
30890                                 Pointable        bool
30891                                 Visual           string
30892                                 VisualSize       [3]float32
30893                                 Textures         []Texture
30894                                 SpriteSheetSize  [2]int16 // in sprites.
30895                                 SpritePos        [2]int16 // in sprite sheet.
30896                                 Visible          bool
30897                                 MakeFootstepSnds bool
30898                                 RotateSpeed      float32 // in radians per second.
30899                                 Mesh             string
30900                                 Colors           []color.NRGBA
30901                                 CollideWithAOs   bool
30902                                 StepHeight       float32
30903                                 FaceRotateDir    bool
30904                                 FaceRotateDirOff float32 // in degrees.
30905                                 BackfaceCull     bool
30906                                 Nametag          string
30907                                 NametagColor     color.NRGBA
30908                                 FaceRotateSpeed  float32 // in degrees per second.
30909                                 Infotext         string
30910                                 Itemstring       string
30911                                 Glow             int8
30912                                 MaxBreath        uint16  // Player only.
30913                                 EyeHeight        float32 // Player only.
30914                                 ZoomFOV          float32 // in degrees. Player only.
30915                                 UseTextureAlpha  bool
30916                                 DmgTextureMod    Texture // suffix
30917                                 Shaded           bool
30918                                 ShowOnMinimap    bool
30919                                 NametagBG        color.NRGBA
30920                         }))(obj)).Textures)[local342]).deserialize(r)
30921                 }); err != nil {
30922                         if err == io.EOF {
30923                                 chk(io.EOF)
30924                         }
30925                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
30926                 }
30927         }
30928         for local343 := range (*(*(struct {
30929                 MaxHP            uint16 // Player only.
30930                 CollideWithNodes bool
30931                 Weight           float32 // deprecated
30932                 ColBox, SelBox   Box
30933                 Pointable        bool
30934                 Visual           string
30935                 VisualSize       [3]float32
30936                 Textures         []Texture
30937                 SpriteSheetSize  [2]int16 // in sprites.
30938                 SpritePos        [2]int16 // in sprite sheet.
30939                 Visible          bool
30940                 MakeFootstepSnds bool
30941                 RotateSpeed      float32 // in radians per second.
30942                 Mesh             string
30943                 Colors           []color.NRGBA
30944                 CollideWithAOs   bool
30945                 StepHeight       float32
30946                 FaceRotateDir    bool
30947                 FaceRotateDirOff float32 // in degrees.
30948                 BackfaceCull     bool
30949                 Nametag          string
30950                 NametagColor     color.NRGBA
30951                 FaceRotateSpeed  float32 // in degrees per second.
30952                 Infotext         string
30953                 Itemstring       string
30954                 Glow             int8
30955                 MaxBreath        uint16  // Player only.
30956                 EyeHeight        float32 // Player only.
30957                 ZoomFOV          float32 // in degrees. Player only.
30958                 UseTextureAlpha  bool
30959                 DmgTextureMod    Texture // suffix
30960                 Shaded           bool
30961                 ShowOnMinimap    bool
30962                 NametagBG        color.NRGBA
30963         }))(obj)).SpriteSheetSize {
30964                 {
30965                         p := &((*(*(struct {
30966                                 MaxHP            uint16 // Player only.
30967                                 CollideWithNodes bool
30968                                 Weight           float32 // deprecated
30969                                 ColBox, SelBox   Box
30970                                 Pointable        bool
30971                                 Visual           string
30972                                 VisualSize       [3]float32
30973                                 Textures         []Texture
30974                                 SpriteSheetSize  [2]int16 // in sprites.
30975                                 SpritePos        [2]int16 // in sprite sheet.
30976                                 Visible          bool
30977                                 MakeFootstepSnds bool
30978                                 RotateSpeed      float32 // in radians per second.
30979                                 Mesh             string
30980                                 Colors           []color.NRGBA
30981                                 CollideWithAOs   bool
30982                                 StepHeight       float32
30983                                 FaceRotateDir    bool
30984                                 FaceRotateDirOff float32 // in degrees.
30985                                 BackfaceCull     bool
30986                                 Nametag          string
30987                                 NametagColor     color.NRGBA
30988                                 FaceRotateSpeed  float32 // in degrees per second.
30989                                 Infotext         string
30990                                 Itemstring       string
30991                                 Glow             int8
30992                                 MaxBreath        uint16  // Player only.
30993                                 EyeHeight        float32 // Player only.
30994                                 ZoomFOV          float32 // in degrees. Player only.
30995                                 UseTextureAlpha  bool
30996                                 DmgTextureMod    Texture // suffix
30997                                 Shaded           bool
30998                                 ShowOnMinimap    bool
30999                                 NametagBG        color.NRGBA
31000                         }))(obj)).SpriteSheetSize)[local343]
31001                         *p = int16(read16(r))
31002                 }
31003         }
31004         for local344 := range (*(*(struct {
31005                 MaxHP            uint16 // Player only.
31006                 CollideWithNodes bool
31007                 Weight           float32 // deprecated
31008                 ColBox, SelBox   Box
31009                 Pointable        bool
31010                 Visual           string
31011                 VisualSize       [3]float32
31012                 Textures         []Texture
31013                 SpriteSheetSize  [2]int16 // in sprites.
31014                 SpritePos        [2]int16 // in sprite sheet.
31015                 Visible          bool
31016                 MakeFootstepSnds bool
31017                 RotateSpeed      float32 // in radians per second.
31018                 Mesh             string
31019                 Colors           []color.NRGBA
31020                 CollideWithAOs   bool
31021                 StepHeight       float32
31022                 FaceRotateDir    bool
31023                 FaceRotateDirOff float32 // in degrees.
31024                 BackfaceCull     bool
31025                 Nametag          string
31026                 NametagColor     color.NRGBA
31027                 FaceRotateSpeed  float32 // in degrees per second.
31028                 Infotext         string
31029                 Itemstring       string
31030                 Glow             int8
31031                 MaxBreath        uint16  // Player only.
31032                 EyeHeight        float32 // Player only.
31033                 ZoomFOV          float32 // in degrees. Player only.
31034                 UseTextureAlpha  bool
31035                 DmgTextureMod    Texture // suffix
31036                 Shaded           bool
31037                 ShowOnMinimap    bool
31038                 NametagBG        color.NRGBA
31039         }))(obj)).SpritePos {
31040                 {
31041                         p := &((*(*(struct {
31042                                 MaxHP            uint16 // Player only.
31043                                 CollideWithNodes bool
31044                                 Weight           float32 // deprecated
31045                                 ColBox, SelBox   Box
31046                                 Pointable        bool
31047                                 Visual           string
31048                                 VisualSize       [3]float32
31049                                 Textures         []Texture
31050                                 SpriteSheetSize  [2]int16 // in sprites.
31051                                 SpritePos        [2]int16 // in sprite sheet.
31052                                 Visible          bool
31053                                 MakeFootstepSnds bool
31054                                 RotateSpeed      float32 // in radians per second.
31055                                 Mesh             string
31056                                 Colors           []color.NRGBA
31057                                 CollideWithAOs   bool
31058                                 StepHeight       float32
31059                                 FaceRotateDir    bool
31060                                 FaceRotateDirOff float32 // in degrees.
31061                                 BackfaceCull     bool
31062                                 Nametag          string
31063                                 NametagColor     color.NRGBA
31064                                 FaceRotateSpeed  float32 // in degrees per second.
31065                                 Infotext         string
31066                                 Itemstring       string
31067                                 Glow             int8
31068                                 MaxBreath        uint16  // Player only.
31069                                 EyeHeight        float32 // Player only.
31070                                 ZoomFOV          float32 // in degrees. Player only.
31071                                 UseTextureAlpha  bool
31072                                 DmgTextureMod    Texture // suffix
31073                                 Shaded           bool
31074                                 ShowOnMinimap    bool
31075                                 NametagBG        color.NRGBA
31076                         }))(obj)).SpritePos)[local344]
31077                         *p = int16(read16(r))
31078                 }
31079         }
31080         {
31081                 p := &(*(*(struct {
31082                         MaxHP            uint16 // Player only.
31083                         CollideWithNodes bool
31084                         Weight           float32 // deprecated
31085                         ColBox, SelBox   Box
31086                         Pointable        bool
31087                         Visual           string
31088                         VisualSize       [3]float32
31089                         Textures         []Texture
31090                         SpriteSheetSize  [2]int16 // in sprites.
31091                         SpritePos        [2]int16 // in sprite sheet.
31092                         Visible          bool
31093                         MakeFootstepSnds bool
31094                         RotateSpeed      float32 // in radians per second.
31095                         Mesh             string
31096                         Colors           []color.NRGBA
31097                         CollideWithAOs   bool
31098                         StepHeight       float32
31099                         FaceRotateDir    bool
31100                         FaceRotateDirOff float32 // in degrees.
31101                         BackfaceCull     bool
31102                         Nametag          string
31103                         NametagColor     color.NRGBA
31104                         FaceRotateSpeed  float32 // in degrees per second.
31105                         Infotext         string
31106                         Itemstring       string
31107                         Glow             int8
31108                         MaxBreath        uint16  // Player only.
31109                         EyeHeight        float32 // Player only.
31110                         ZoomFOV          float32 // in degrees. Player only.
31111                         UseTextureAlpha  bool
31112                         DmgTextureMod    Texture // suffix
31113                         Shaded           bool
31114                         ShowOnMinimap    bool
31115                         NametagBG        color.NRGBA
31116                 }))(obj)).Visible
31117                 switch n := read8(r); n {
31118                 case 0:
31119                         *p = false
31120                 case 1:
31121                         *p = true
31122                 default:
31123                         chk(fmt.Errorf("invalid bool: %d", n))
31124                 }
31125         }
31126         {
31127                 p := &(*(*(struct {
31128                         MaxHP            uint16 // Player only.
31129                         CollideWithNodes bool
31130                         Weight           float32 // deprecated
31131                         ColBox, SelBox   Box
31132                         Pointable        bool
31133                         Visual           string
31134                         VisualSize       [3]float32
31135                         Textures         []Texture
31136                         SpriteSheetSize  [2]int16 // in sprites.
31137                         SpritePos        [2]int16 // in sprite sheet.
31138                         Visible          bool
31139                         MakeFootstepSnds bool
31140                         RotateSpeed      float32 // in radians per second.
31141                         Mesh             string
31142                         Colors           []color.NRGBA
31143                         CollideWithAOs   bool
31144                         StepHeight       float32
31145                         FaceRotateDir    bool
31146                         FaceRotateDirOff float32 // in degrees.
31147                         BackfaceCull     bool
31148                         Nametag          string
31149                         NametagColor     color.NRGBA
31150                         FaceRotateSpeed  float32 // in degrees per second.
31151                         Infotext         string
31152                         Itemstring       string
31153                         Glow             int8
31154                         MaxBreath        uint16  // Player only.
31155                         EyeHeight        float32 // Player only.
31156                         ZoomFOV          float32 // in degrees. Player only.
31157                         UseTextureAlpha  bool
31158                         DmgTextureMod    Texture // suffix
31159                         Shaded           bool
31160                         ShowOnMinimap    bool
31161                         NametagBG        color.NRGBA
31162                 }))(obj)).MakeFootstepSnds
31163                 switch n := read8(r); n {
31164                 case 0:
31165                         *p = false
31166                 case 1:
31167                         *p = true
31168                 default:
31169                         chk(fmt.Errorf("invalid bool: %d", n))
31170                 }
31171         }
31172         {
31173                 p := &(*(*(struct {
31174                         MaxHP            uint16 // Player only.
31175                         CollideWithNodes bool
31176                         Weight           float32 // deprecated
31177                         ColBox, SelBox   Box
31178                         Pointable        bool
31179                         Visual           string
31180                         VisualSize       [3]float32
31181                         Textures         []Texture
31182                         SpriteSheetSize  [2]int16 // in sprites.
31183                         SpritePos        [2]int16 // in sprite sheet.
31184                         Visible          bool
31185                         MakeFootstepSnds bool
31186                         RotateSpeed      float32 // in radians per second.
31187                         Mesh             string
31188                         Colors           []color.NRGBA
31189                         CollideWithAOs   bool
31190                         StepHeight       float32
31191                         FaceRotateDir    bool
31192                         FaceRotateDirOff float32 // in degrees.
31193                         BackfaceCull     bool
31194                         Nametag          string
31195                         NametagColor     color.NRGBA
31196                         FaceRotateSpeed  float32 // in degrees per second.
31197                         Infotext         string
31198                         Itemstring       string
31199                         Glow             int8
31200                         MaxBreath        uint16  // Player only.
31201                         EyeHeight        float32 // Player only.
31202                         ZoomFOV          float32 // in degrees. Player only.
31203                         UseTextureAlpha  bool
31204                         DmgTextureMod    Texture // suffix
31205                         Shaded           bool
31206                         ShowOnMinimap    bool
31207                         NametagBG        color.NRGBA
31208                 }))(obj)).RotateSpeed
31209                 *p = math.Float32frombits(read32(r))
31210         }
31211         var local345 []uint8
31212         var local346 uint16
31213         {
31214                 p := &local346
31215                 *p = read16(r)
31216         }
31217         (local345) = make([]uint8, local346)
31218         {
31219                 _, err := io.ReadFull(r, (local345)[:])
31220                 chk(err)
31221         }
31222         ((*(*(struct {
31223                 MaxHP            uint16 // Player only.
31224                 CollideWithNodes bool
31225                 Weight           float32 // deprecated
31226                 ColBox, SelBox   Box
31227                 Pointable        bool
31228                 Visual           string
31229                 VisualSize       [3]float32
31230                 Textures         []Texture
31231                 SpriteSheetSize  [2]int16 // in sprites.
31232                 SpritePos        [2]int16 // in sprite sheet.
31233                 Visible          bool
31234                 MakeFootstepSnds bool
31235                 RotateSpeed      float32 // in radians per second.
31236                 Mesh             string
31237                 Colors           []color.NRGBA
31238                 CollideWithAOs   bool
31239                 StepHeight       float32
31240                 FaceRotateDir    bool
31241                 FaceRotateDirOff float32 // in degrees.
31242                 BackfaceCull     bool
31243                 Nametag          string
31244                 NametagColor     color.NRGBA
31245                 FaceRotateSpeed  float32 // in degrees per second.
31246                 Infotext         string
31247                 Itemstring       string
31248                 Glow             int8
31249                 MaxBreath        uint16  // Player only.
31250                 EyeHeight        float32 // Player only.
31251                 ZoomFOV          float32 // in degrees. Player only.
31252                 UseTextureAlpha  bool
31253                 DmgTextureMod    Texture // suffix
31254                 Shaded           bool
31255                 ShowOnMinimap    bool
31256                 NametagBG        color.NRGBA
31257         }))(obj)).Mesh) = string(local345)
31258         var local347 uint16
31259         {
31260                 p := &local347
31261                 *p = read16(r)
31262         }
31263         ((*(*(struct {
31264                 MaxHP            uint16 // Player only.
31265                 CollideWithNodes bool
31266                 Weight           float32 // deprecated
31267                 ColBox, SelBox   Box
31268                 Pointable        bool
31269                 Visual           string
31270                 VisualSize       [3]float32
31271                 Textures         []Texture
31272                 SpriteSheetSize  [2]int16 // in sprites.
31273                 SpritePos        [2]int16 // in sprite sheet.
31274                 Visible          bool
31275                 MakeFootstepSnds bool
31276                 RotateSpeed      float32 // in radians per second.
31277                 Mesh             string
31278                 Colors           []color.NRGBA
31279                 CollideWithAOs   bool
31280                 StepHeight       float32
31281                 FaceRotateDir    bool
31282                 FaceRotateDirOff float32 // in degrees.
31283                 BackfaceCull     bool
31284                 Nametag          string
31285                 NametagColor     color.NRGBA
31286                 FaceRotateSpeed  float32 // in degrees per second.
31287                 Infotext         string
31288                 Itemstring       string
31289                 Glow             int8
31290                 MaxBreath        uint16  // Player only.
31291                 EyeHeight        float32 // Player only.
31292                 ZoomFOV          float32 // in degrees. Player only.
31293                 UseTextureAlpha  bool
31294                 DmgTextureMod    Texture // suffix
31295                 Shaded           bool
31296                 ShowOnMinimap    bool
31297                 NametagBG        color.NRGBA
31298         }))(obj)).Colors) = make([]color.NRGBA, local347)
31299         for local348 := range (*(*(struct {
31300                 MaxHP            uint16 // Player only.
31301                 CollideWithNodes bool
31302                 Weight           float32 // deprecated
31303                 ColBox, SelBox   Box
31304                 Pointable        bool
31305                 Visual           string
31306                 VisualSize       [3]float32
31307                 Textures         []Texture
31308                 SpriteSheetSize  [2]int16 // in sprites.
31309                 SpritePos        [2]int16 // in sprite sheet.
31310                 Visible          bool
31311                 MakeFootstepSnds bool
31312                 RotateSpeed      float32 // in radians per second.
31313                 Mesh             string
31314                 Colors           []color.NRGBA
31315                 CollideWithAOs   bool
31316                 StepHeight       float32
31317                 FaceRotateDir    bool
31318                 FaceRotateDirOff float32 // in degrees.
31319                 BackfaceCull     bool
31320                 Nametag          string
31321                 NametagColor     color.NRGBA
31322                 FaceRotateSpeed  float32 // in degrees per second.
31323                 Infotext         string
31324                 Itemstring       string
31325                 Glow             int8
31326                 MaxBreath        uint16  // Player only.
31327                 EyeHeight        float32 // Player only.
31328                 ZoomFOV          float32 // in degrees. Player only.
31329                 UseTextureAlpha  bool
31330                 DmgTextureMod    Texture // suffix
31331                 Shaded           bool
31332                 ShowOnMinimap    bool
31333                 NametagBG        color.NRGBA
31334         }))(obj)).Colors {
31335                 {
31336                         p := &((*(*(struct {
31337                                 MaxHP            uint16 // Player only.
31338                                 CollideWithNodes bool
31339                                 Weight           float32 // deprecated
31340                                 ColBox, SelBox   Box
31341                                 Pointable        bool
31342                                 Visual           string
31343                                 VisualSize       [3]float32
31344                                 Textures         []Texture
31345                                 SpriteSheetSize  [2]int16 // in sprites.
31346                                 SpritePos        [2]int16 // in sprite sheet.
31347                                 Visible          bool
31348                                 MakeFootstepSnds bool
31349                                 RotateSpeed      float32 // in radians per second.
31350                                 Mesh             string
31351                                 Colors           []color.NRGBA
31352                                 CollideWithAOs   bool
31353                                 StepHeight       float32
31354                                 FaceRotateDir    bool
31355                                 FaceRotateDirOff float32 // in degrees.
31356                                 BackfaceCull     bool
31357                                 Nametag          string
31358                                 NametagColor     color.NRGBA
31359                                 FaceRotateSpeed  float32 // in degrees per second.
31360                                 Infotext         string
31361                                 Itemstring       string
31362                                 Glow             int8
31363                                 MaxBreath        uint16  // Player only.
31364                                 EyeHeight        float32 // Player only.
31365                                 ZoomFOV          float32 // in degrees. Player only.
31366                                 UseTextureAlpha  bool
31367                                 DmgTextureMod    Texture // suffix
31368                                 Shaded           bool
31369                                 ShowOnMinimap    bool
31370                                 NametagBG        color.NRGBA
31371                         }))(obj)).Colors)[local348]
31372                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31373                 }
31374         }
31375         {
31376                 p := &(*(*(struct {
31377                         MaxHP            uint16 // Player only.
31378                         CollideWithNodes bool
31379                         Weight           float32 // deprecated
31380                         ColBox, SelBox   Box
31381                         Pointable        bool
31382                         Visual           string
31383                         VisualSize       [3]float32
31384                         Textures         []Texture
31385                         SpriteSheetSize  [2]int16 // in sprites.
31386                         SpritePos        [2]int16 // in sprite sheet.
31387                         Visible          bool
31388                         MakeFootstepSnds bool
31389                         RotateSpeed      float32 // in radians per second.
31390                         Mesh             string
31391                         Colors           []color.NRGBA
31392                         CollideWithAOs   bool
31393                         StepHeight       float32
31394                         FaceRotateDir    bool
31395                         FaceRotateDirOff float32 // in degrees.
31396                         BackfaceCull     bool
31397                         Nametag          string
31398                         NametagColor     color.NRGBA
31399                         FaceRotateSpeed  float32 // in degrees per second.
31400                         Infotext         string
31401                         Itemstring       string
31402                         Glow             int8
31403                         MaxBreath        uint16  // Player only.
31404                         EyeHeight        float32 // Player only.
31405                         ZoomFOV          float32 // in degrees. Player only.
31406                         UseTextureAlpha  bool
31407                         DmgTextureMod    Texture // suffix
31408                         Shaded           bool
31409                         ShowOnMinimap    bool
31410                         NametagBG        color.NRGBA
31411                 }))(obj)).CollideWithAOs
31412                 switch n := read8(r); n {
31413                 case 0:
31414                         *p = false
31415                 case 1:
31416                         *p = true
31417                 default:
31418                         chk(fmt.Errorf("invalid bool: %d", n))
31419                 }
31420         }
31421         {
31422                 p := &(*(*(struct {
31423                         MaxHP            uint16 // Player only.
31424                         CollideWithNodes bool
31425                         Weight           float32 // deprecated
31426                         ColBox, SelBox   Box
31427                         Pointable        bool
31428                         Visual           string
31429                         VisualSize       [3]float32
31430                         Textures         []Texture
31431                         SpriteSheetSize  [2]int16 // in sprites.
31432                         SpritePos        [2]int16 // in sprite sheet.
31433                         Visible          bool
31434                         MakeFootstepSnds bool
31435                         RotateSpeed      float32 // in radians per second.
31436                         Mesh             string
31437                         Colors           []color.NRGBA
31438                         CollideWithAOs   bool
31439                         StepHeight       float32
31440                         FaceRotateDir    bool
31441                         FaceRotateDirOff float32 // in degrees.
31442                         BackfaceCull     bool
31443                         Nametag          string
31444                         NametagColor     color.NRGBA
31445                         FaceRotateSpeed  float32 // in degrees per second.
31446                         Infotext         string
31447                         Itemstring       string
31448                         Glow             int8
31449                         MaxBreath        uint16  // Player only.
31450                         EyeHeight        float32 // Player only.
31451                         ZoomFOV          float32 // in degrees. Player only.
31452                         UseTextureAlpha  bool
31453                         DmgTextureMod    Texture // suffix
31454                         Shaded           bool
31455                         ShowOnMinimap    bool
31456                         NametagBG        color.NRGBA
31457                 }))(obj)).StepHeight
31458                 *p = math.Float32frombits(read32(r))
31459         }
31460         {
31461                 p := &(*(*(struct {
31462                         MaxHP            uint16 // Player only.
31463                         CollideWithNodes bool
31464                         Weight           float32 // deprecated
31465                         ColBox, SelBox   Box
31466                         Pointable        bool
31467                         Visual           string
31468                         VisualSize       [3]float32
31469                         Textures         []Texture
31470                         SpriteSheetSize  [2]int16 // in sprites.
31471                         SpritePos        [2]int16 // in sprite sheet.
31472                         Visible          bool
31473                         MakeFootstepSnds bool
31474                         RotateSpeed      float32 // in radians per second.
31475                         Mesh             string
31476                         Colors           []color.NRGBA
31477                         CollideWithAOs   bool
31478                         StepHeight       float32
31479                         FaceRotateDir    bool
31480                         FaceRotateDirOff float32 // in degrees.
31481                         BackfaceCull     bool
31482                         Nametag          string
31483                         NametagColor     color.NRGBA
31484                         FaceRotateSpeed  float32 // in degrees per second.
31485                         Infotext         string
31486                         Itemstring       string
31487                         Glow             int8
31488                         MaxBreath        uint16  // Player only.
31489                         EyeHeight        float32 // Player only.
31490                         ZoomFOV          float32 // in degrees. Player only.
31491                         UseTextureAlpha  bool
31492                         DmgTextureMod    Texture // suffix
31493                         Shaded           bool
31494                         ShowOnMinimap    bool
31495                         NametagBG        color.NRGBA
31496                 }))(obj)).FaceRotateDir
31497                 switch n := read8(r); n {
31498                 case 0:
31499                         *p = false
31500                 case 1:
31501                         *p = true
31502                 default:
31503                         chk(fmt.Errorf("invalid bool: %d", n))
31504                 }
31505         }
31506         {
31507                 p := &(*(*(struct {
31508                         MaxHP            uint16 // Player only.
31509                         CollideWithNodes bool
31510                         Weight           float32 // deprecated
31511                         ColBox, SelBox   Box
31512                         Pointable        bool
31513                         Visual           string
31514                         VisualSize       [3]float32
31515                         Textures         []Texture
31516                         SpriteSheetSize  [2]int16 // in sprites.
31517                         SpritePos        [2]int16 // in sprite sheet.
31518                         Visible          bool
31519                         MakeFootstepSnds bool
31520                         RotateSpeed      float32 // in radians per second.
31521                         Mesh             string
31522                         Colors           []color.NRGBA
31523                         CollideWithAOs   bool
31524                         StepHeight       float32
31525                         FaceRotateDir    bool
31526                         FaceRotateDirOff float32 // in degrees.
31527                         BackfaceCull     bool
31528                         Nametag          string
31529                         NametagColor     color.NRGBA
31530                         FaceRotateSpeed  float32 // in degrees per second.
31531                         Infotext         string
31532                         Itemstring       string
31533                         Glow             int8
31534                         MaxBreath        uint16  // Player only.
31535                         EyeHeight        float32 // Player only.
31536                         ZoomFOV          float32 // in degrees. Player only.
31537                         UseTextureAlpha  bool
31538                         DmgTextureMod    Texture // suffix
31539                         Shaded           bool
31540                         ShowOnMinimap    bool
31541                         NametagBG        color.NRGBA
31542                 }))(obj)).FaceRotateDirOff
31543                 *p = math.Float32frombits(read32(r))
31544         }
31545         {
31546                 p := &(*(*(struct {
31547                         MaxHP            uint16 // Player only.
31548                         CollideWithNodes bool
31549                         Weight           float32 // deprecated
31550                         ColBox, SelBox   Box
31551                         Pointable        bool
31552                         Visual           string
31553                         VisualSize       [3]float32
31554                         Textures         []Texture
31555                         SpriteSheetSize  [2]int16 // in sprites.
31556                         SpritePos        [2]int16 // in sprite sheet.
31557                         Visible          bool
31558                         MakeFootstepSnds bool
31559                         RotateSpeed      float32 // in radians per second.
31560                         Mesh             string
31561                         Colors           []color.NRGBA
31562                         CollideWithAOs   bool
31563                         StepHeight       float32
31564                         FaceRotateDir    bool
31565                         FaceRotateDirOff float32 // in degrees.
31566                         BackfaceCull     bool
31567                         Nametag          string
31568                         NametagColor     color.NRGBA
31569                         FaceRotateSpeed  float32 // in degrees per second.
31570                         Infotext         string
31571                         Itemstring       string
31572                         Glow             int8
31573                         MaxBreath        uint16  // Player only.
31574                         EyeHeight        float32 // Player only.
31575                         ZoomFOV          float32 // in degrees. Player only.
31576                         UseTextureAlpha  bool
31577                         DmgTextureMod    Texture // suffix
31578                         Shaded           bool
31579                         ShowOnMinimap    bool
31580                         NametagBG        color.NRGBA
31581                 }))(obj)).BackfaceCull
31582                 switch n := read8(r); n {
31583                 case 0:
31584                         *p = false
31585                 case 1:
31586                         *p = true
31587                 default:
31588                         chk(fmt.Errorf("invalid bool: %d", n))
31589                 }
31590         }
31591         var local349 []uint8
31592         var local350 uint16
31593         {
31594                 p := &local350
31595                 *p = read16(r)
31596         }
31597         (local349) = make([]uint8, local350)
31598         {
31599                 _, err := io.ReadFull(r, (local349)[:])
31600                 chk(err)
31601         }
31602         ((*(*(struct {
31603                 MaxHP            uint16 // Player only.
31604                 CollideWithNodes bool
31605                 Weight           float32 // deprecated
31606                 ColBox, SelBox   Box
31607                 Pointable        bool
31608                 Visual           string
31609                 VisualSize       [3]float32
31610                 Textures         []Texture
31611                 SpriteSheetSize  [2]int16 // in sprites.
31612                 SpritePos        [2]int16 // in sprite sheet.
31613                 Visible          bool
31614                 MakeFootstepSnds bool
31615                 RotateSpeed      float32 // in radians per second.
31616                 Mesh             string
31617                 Colors           []color.NRGBA
31618                 CollideWithAOs   bool
31619                 StepHeight       float32
31620                 FaceRotateDir    bool
31621                 FaceRotateDirOff float32 // in degrees.
31622                 BackfaceCull     bool
31623                 Nametag          string
31624                 NametagColor     color.NRGBA
31625                 FaceRotateSpeed  float32 // in degrees per second.
31626                 Infotext         string
31627                 Itemstring       string
31628                 Glow             int8
31629                 MaxBreath        uint16  // Player only.
31630                 EyeHeight        float32 // Player only.
31631                 ZoomFOV          float32 // in degrees. Player only.
31632                 UseTextureAlpha  bool
31633                 DmgTextureMod    Texture // suffix
31634                 Shaded           bool
31635                 ShowOnMinimap    bool
31636                 NametagBG        color.NRGBA
31637         }))(obj)).Nametag) = string(local349)
31638         {
31639                 p := &(*(*(struct {
31640                         MaxHP            uint16 // Player only.
31641                         CollideWithNodes bool
31642                         Weight           float32 // deprecated
31643                         ColBox, SelBox   Box
31644                         Pointable        bool
31645                         Visual           string
31646                         VisualSize       [3]float32
31647                         Textures         []Texture
31648                         SpriteSheetSize  [2]int16 // in sprites.
31649                         SpritePos        [2]int16 // in sprite sheet.
31650                         Visible          bool
31651                         MakeFootstepSnds bool
31652                         RotateSpeed      float32 // in radians per second.
31653                         Mesh             string
31654                         Colors           []color.NRGBA
31655                         CollideWithAOs   bool
31656                         StepHeight       float32
31657                         FaceRotateDir    bool
31658                         FaceRotateDirOff float32 // in degrees.
31659                         BackfaceCull     bool
31660                         Nametag          string
31661                         NametagColor     color.NRGBA
31662                         FaceRotateSpeed  float32 // in degrees per second.
31663                         Infotext         string
31664                         Itemstring       string
31665                         Glow             int8
31666                         MaxBreath        uint16  // Player only.
31667                         EyeHeight        float32 // Player only.
31668                         ZoomFOV          float32 // in degrees. Player only.
31669                         UseTextureAlpha  bool
31670                         DmgTextureMod    Texture // suffix
31671                         Shaded           bool
31672                         ShowOnMinimap    bool
31673                         NametagBG        color.NRGBA
31674                 }))(obj)).NametagColor
31675                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31676         }
31677         {
31678                 p := &(*(*(struct {
31679                         MaxHP            uint16 // Player only.
31680                         CollideWithNodes bool
31681                         Weight           float32 // deprecated
31682                         ColBox, SelBox   Box
31683                         Pointable        bool
31684                         Visual           string
31685                         VisualSize       [3]float32
31686                         Textures         []Texture
31687                         SpriteSheetSize  [2]int16 // in sprites.
31688                         SpritePos        [2]int16 // in sprite sheet.
31689                         Visible          bool
31690                         MakeFootstepSnds bool
31691                         RotateSpeed      float32 // in radians per second.
31692                         Mesh             string
31693                         Colors           []color.NRGBA
31694                         CollideWithAOs   bool
31695                         StepHeight       float32
31696                         FaceRotateDir    bool
31697                         FaceRotateDirOff float32 // in degrees.
31698                         BackfaceCull     bool
31699                         Nametag          string
31700                         NametagColor     color.NRGBA
31701                         FaceRotateSpeed  float32 // in degrees per second.
31702                         Infotext         string
31703                         Itemstring       string
31704                         Glow             int8
31705                         MaxBreath        uint16  // Player only.
31706                         EyeHeight        float32 // Player only.
31707                         ZoomFOV          float32 // in degrees. Player only.
31708                         UseTextureAlpha  bool
31709                         DmgTextureMod    Texture // suffix
31710                         Shaded           bool
31711                         ShowOnMinimap    bool
31712                         NametagBG        color.NRGBA
31713                 }))(obj)).FaceRotateSpeed
31714                 *p = math.Float32frombits(read32(r))
31715         }
31716         var local351 []uint8
31717         var local352 uint16
31718         {
31719                 p := &local352
31720                 *p = read16(r)
31721         }
31722         (local351) = make([]uint8, local352)
31723         {
31724                 _, err := io.ReadFull(r, (local351)[:])
31725                 chk(err)
31726         }
31727         ((*(*(struct {
31728                 MaxHP            uint16 // Player only.
31729                 CollideWithNodes bool
31730                 Weight           float32 // deprecated
31731                 ColBox, SelBox   Box
31732                 Pointable        bool
31733                 Visual           string
31734                 VisualSize       [3]float32
31735                 Textures         []Texture
31736                 SpriteSheetSize  [2]int16 // in sprites.
31737                 SpritePos        [2]int16 // in sprite sheet.
31738                 Visible          bool
31739                 MakeFootstepSnds bool
31740                 RotateSpeed      float32 // in radians per second.
31741                 Mesh             string
31742                 Colors           []color.NRGBA
31743                 CollideWithAOs   bool
31744                 StepHeight       float32
31745                 FaceRotateDir    bool
31746                 FaceRotateDirOff float32 // in degrees.
31747                 BackfaceCull     bool
31748                 Nametag          string
31749                 NametagColor     color.NRGBA
31750                 FaceRotateSpeed  float32 // in degrees per second.
31751                 Infotext         string
31752                 Itemstring       string
31753                 Glow             int8
31754                 MaxBreath        uint16  // Player only.
31755                 EyeHeight        float32 // Player only.
31756                 ZoomFOV          float32 // in degrees. Player only.
31757                 UseTextureAlpha  bool
31758                 DmgTextureMod    Texture // suffix
31759                 Shaded           bool
31760                 ShowOnMinimap    bool
31761                 NametagBG        color.NRGBA
31762         }))(obj)).Infotext) = string(local351)
31763         var local353 []uint8
31764         var local354 uint16
31765         {
31766                 p := &local354
31767                 *p = read16(r)
31768         }
31769         (local353) = make([]uint8, local354)
31770         {
31771                 _, err := io.ReadFull(r, (local353)[:])
31772                 chk(err)
31773         }
31774         ((*(*(struct {
31775                 MaxHP            uint16 // Player only.
31776                 CollideWithNodes bool
31777                 Weight           float32 // deprecated
31778                 ColBox, SelBox   Box
31779                 Pointable        bool
31780                 Visual           string
31781                 VisualSize       [3]float32
31782                 Textures         []Texture
31783                 SpriteSheetSize  [2]int16 // in sprites.
31784                 SpritePos        [2]int16 // in sprite sheet.
31785                 Visible          bool
31786                 MakeFootstepSnds bool
31787                 RotateSpeed      float32 // in radians per second.
31788                 Mesh             string
31789                 Colors           []color.NRGBA
31790                 CollideWithAOs   bool
31791                 StepHeight       float32
31792                 FaceRotateDir    bool
31793                 FaceRotateDirOff float32 // in degrees.
31794                 BackfaceCull     bool
31795                 Nametag          string
31796                 NametagColor     color.NRGBA
31797                 FaceRotateSpeed  float32 // in degrees per second.
31798                 Infotext         string
31799                 Itemstring       string
31800                 Glow             int8
31801                 MaxBreath        uint16  // Player only.
31802                 EyeHeight        float32 // Player only.
31803                 ZoomFOV          float32 // in degrees. Player only.
31804                 UseTextureAlpha  bool
31805                 DmgTextureMod    Texture // suffix
31806                 Shaded           bool
31807                 ShowOnMinimap    bool
31808                 NametagBG        color.NRGBA
31809         }))(obj)).Itemstring) = string(local353)
31810         {
31811                 p := &(*(*(struct {
31812                         MaxHP            uint16 // Player only.
31813                         CollideWithNodes bool
31814                         Weight           float32 // deprecated
31815                         ColBox, SelBox   Box
31816                         Pointable        bool
31817                         Visual           string
31818                         VisualSize       [3]float32
31819                         Textures         []Texture
31820                         SpriteSheetSize  [2]int16 // in sprites.
31821                         SpritePos        [2]int16 // in sprite sheet.
31822                         Visible          bool
31823                         MakeFootstepSnds bool
31824                         RotateSpeed      float32 // in radians per second.
31825                         Mesh             string
31826                         Colors           []color.NRGBA
31827                         CollideWithAOs   bool
31828                         StepHeight       float32
31829                         FaceRotateDir    bool
31830                         FaceRotateDirOff float32 // in degrees.
31831                         BackfaceCull     bool
31832                         Nametag          string
31833                         NametagColor     color.NRGBA
31834                         FaceRotateSpeed  float32 // in degrees per second.
31835                         Infotext         string
31836                         Itemstring       string
31837                         Glow             int8
31838                         MaxBreath        uint16  // Player only.
31839                         EyeHeight        float32 // Player only.
31840                         ZoomFOV          float32 // in degrees. Player only.
31841                         UseTextureAlpha  bool
31842                         DmgTextureMod    Texture // suffix
31843                         Shaded           bool
31844                         ShowOnMinimap    bool
31845                         NametagBG        color.NRGBA
31846                 }))(obj)).Glow
31847                 *p = int8(read8(r))
31848         }
31849         {
31850                 p := &(*(*(struct {
31851                         MaxHP            uint16 // Player only.
31852                         CollideWithNodes bool
31853                         Weight           float32 // deprecated
31854                         ColBox, SelBox   Box
31855                         Pointable        bool
31856                         Visual           string
31857                         VisualSize       [3]float32
31858                         Textures         []Texture
31859                         SpriteSheetSize  [2]int16 // in sprites.
31860                         SpritePos        [2]int16 // in sprite sheet.
31861                         Visible          bool
31862                         MakeFootstepSnds bool
31863                         RotateSpeed      float32 // in radians per second.
31864                         Mesh             string
31865                         Colors           []color.NRGBA
31866                         CollideWithAOs   bool
31867                         StepHeight       float32
31868                         FaceRotateDir    bool
31869                         FaceRotateDirOff float32 // in degrees.
31870                         BackfaceCull     bool
31871                         Nametag          string
31872                         NametagColor     color.NRGBA
31873                         FaceRotateSpeed  float32 // in degrees per second.
31874                         Infotext         string
31875                         Itemstring       string
31876                         Glow             int8
31877                         MaxBreath        uint16  // Player only.
31878                         EyeHeight        float32 // Player only.
31879                         ZoomFOV          float32 // in degrees. Player only.
31880                         UseTextureAlpha  bool
31881                         DmgTextureMod    Texture // suffix
31882                         Shaded           bool
31883                         ShowOnMinimap    bool
31884                         NametagBG        color.NRGBA
31885                 }))(obj)).MaxBreath
31886                 *p = read16(r)
31887         }
31888         {
31889                 p := &(*(*(struct {
31890                         MaxHP            uint16 // Player only.
31891                         CollideWithNodes bool
31892                         Weight           float32 // deprecated
31893                         ColBox, SelBox   Box
31894                         Pointable        bool
31895                         Visual           string
31896                         VisualSize       [3]float32
31897                         Textures         []Texture
31898                         SpriteSheetSize  [2]int16 // in sprites.
31899                         SpritePos        [2]int16 // in sprite sheet.
31900                         Visible          bool
31901                         MakeFootstepSnds bool
31902                         RotateSpeed      float32 // in radians per second.
31903                         Mesh             string
31904                         Colors           []color.NRGBA
31905                         CollideWithAOs   bool
31906                         StepHeight       float32
31907                         FaceRotateDir    bool
31908                         FaceRotateDirOff float32 // in degrees.
31909                         BackfaceCull     bool
31910                         Nametag          string
31911                         NametagColor     color.NRGBA
31912                         FaceRotateSpeed  float32 // in degrees per second.
31913                         Infotext         string
31914                         Itemstring       string
31915                         Glow             int8
31916                         MaxBreath        uint16  // Player only.
31917                         EyeHeight        float32 // Player only.
31918                         ZoomFOV          float32 // in degrees. Player only.
31919                         UseTextureAlpha  bool
31920                         DmgTextureMod    Texture // suffix
31921                         Shaded           bool
31922                         ShowOnMinimap    bool
31923                         NametagBG        color.NRGBA
31924                 }))(obj)).EyeHeight
31925                 *p = math.Float32frombits(read32(r))
31926         }
31927         {
31928                 p := &(*(*(struct {
31929                         MaxHP            uint16 // Player only.
31930                         CollideWithNodes bool
31931                         Weight           float32 // deprecated
31932                         ColBox, SelBox   Box
31933                         Pointable        bool
31934                         Visual           string
31935                         VisualSize       [3]float32
31936                         Textures         []Texture
31937                         SpriteSheetSize  [2]int16 // in sprites.
31938                         SpritePos        [2]int16 // in sprite sheet.
31939                         Visible          bool
31940                         MakeFootstepSnds bool
31941                         RotateSpeed      float32 // in radians per second.
31942                         Mesh             string
31943                         Colors           []color.NRGBA
31944                         CollideWithAOs   bool
31945                         StepHeight       float32
31946                         FaceRotateDir    bool
31947                         FaceRotateDirOff float32 // in degrees.
31948                         BackfaceCull     bool
31949                         Nametag          string
31950                         NametagColor     color.NRGBA
31951                         FaceRotateSpeed  float32 // in degrees per second.
31952                         Infotext         string
31953                         Itemstring       string
31954                         Glow             int8
31955                         MaxBreath        uint16  // Player only.
31956                         EyeHeight        float32 // Player only.
31957                         ZoomFOV          float32 // in degrees. Player only.
31958                         UseTextureAlpha  bool
31959                         DmgTextureMod    Texture // suffix
31960                         Shaded           bool
31961                         ShowOnMinimap    bool
31962                         NametagBG        color.NRGBA
31963                 }))(obj)).ZoomFOV
31964                 *p = math.Float32frombits(read32(r))
31965         }
31966         {
31967                 p := &(*(*(struct {
31968                         MaxHP            uint16 // Player only.
31969                         CollideWithNodes bool
31970                         Weight           float32 // deprecated
31971                         ColBox, SelBox   Box
31972                         Pointable        bool
31973                         Visual           string
31974                         VisualSize       [3]float32
31975                         Textures         []Texture
31976                         SpriteSheetSize  [2]int16 // in sprites.
31977                         SpritePos        [2]int16 // in sprite sheet.
31978                         Visible          bool
31979                         MakeFootstepSnds bool
31980                         RotateSpeed      float32 // in radians per second.
31981                         Mesh             string
31982                         Colors           []color.NRGBA
31983                         CollideWithAOs   bool
31984                         StepHeight       float32
31985                         FaceRotateDir    bool
31986                         FaceRotateDirOff float32 // in degrees.
31987                         BackfaceCull     bool
31988                         Nametag          string
31989                         NametagColor     color.NRGBA
31990                         FaceRotateSpeed  float32 // in degrees per second.
31991                         Infotext         string
31992                         Itemstring       string
31993                         Glow             int8
31994                         MaxBreath        uint16  // Player only.
31995                         EyeHeight        float32 // Player only.
31996                         ZoomFOV          float32 // in degrees. Player only.
31997                         UseTextureAlpha  bool
31998                         DmgTextureMod    Texture // suffix
31999                         Shaded           bool
32000                         ShowOnMinimap    bool
32001                         NametagBG        color.NRGBA
32002                 }))(obj)).UseTextureAlpha
32003                 switch n := read8(r); n {
32004                 case 0:
32005                         *p = false
32006                 case 1:
32007                         *p = true
32008                 default:
32009                         chk(fmt.Errorf("invalid bool: %d", n))
32010                 }
32011         }
32012         if err := pcall(func() {
32013                 ((*(*(struct {
32014                         MaxHP            uint16 // Player only.
32015                         CollideWithNodes bool
32016                         Weight           float32 // deprecated
32017                         ColBox, SelBox   Box
32018                         Pointable        bool
32019                         Visual           string
32020                         VisualSize       [3]float32
32021                         Textures         []Texture
32022                         SpriteSheetSize  [2]int16 // in sprites.
32023                         SpritePos        [2]int16 // in sprite sheet.
32024                         Visible          bool
32025                         MakeFootstepSnds bool
32026                         RotateSpeed      float32 // in radians per second.
32027                         Mesh             string
32028                         Colors           []color.NRGBA
32029                         CollideWithAOs   bool
32030                         StepHeight       float32
32031                         FaceRotateDir    bool
32032                         FaceRotateDirOff float32 // in degrees.
32033                         BackfaceCull     bool
32034                         Nametag          string
32035                         NametagColor     color.NRGBA
32036                         FaceRotateSpeed  float32 // in degrees per second.
32037                         Infotext         string
32038                         Itemstring       string
32039                         Glow             int8
32040                         MaxBreath        uint16  // Player only.
32041                         EyeHeight        float32 // Player only.
32042                         ZoomFOV          float32 // in degrees. Player only.
32043                         UseTextureAlpha  bool
32044                         DmgTextureMod    Texture // suffix
32045                         Shaded           bool
32046                         ShowOnMinimap    bool
32047                         NametagBG        color.NRGBA
32048                 }))(obj)).DmgTextureMod).deserialize(r)
32049         }); err != nil {
32050                 if err == io.EOF {
32051                         chk(io.EOF)
32052                 }
32053                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
32054         }
32055         {
32056                 p := &(*(*(struct {
32057                         MaxHP            uint16 // Player only.
32058                         CollideWithNodes bool
32059                         Weight           float32 // deprecated
32060                         ColBox, SelBox   Box
32061                         Pointable        bool
32062                         Visual           string
32063                         VisualSize       [3]float32
32064                         Textures         []Texture
32065                         SpriteSheetSize  [2]int16 // in sprites.
32066                         SpritePos        [2]int16 // in sprite sheet.
32067                         Visible          bool
32068                         MakeFootstepSnds bool
32069                         RotateSpeed      float32 // in radians per second.
32070                         Mesh             string
32071                         Colors           []color.NRGBA
32072                         CollideWithAOs   bool
32073                         StepHeight       float32
32074                         FaceRotateDir    bool
32075                         FaceRotateDirOff float32 // in degrees.
32076                         BackfaceCull     bool
32077                         Nametag          string
32078                         NametagColor     color.NRGBA
32079                         FaceRotateSpeed  float32 // in degrees per second.
32080                         Infotext         string
32081                         Itemstring       string
32082                         Glow             int8
32083                         MaxBreath        uint16  // Player only.
32084                         EyeHeight        float32 // Player only.
32085                         ZoomFOV          float32 // in degrees. Player only.
32086                         UseTextureAlpha  bool
32087                         DmgTextureMod    Texture // suffix
32088                         Shaded           bool
32089                         ShowOnMinimap    bool
32090                         NametagBG        color.NRGBA
32091                 }))(obj)).Shaded
32092                 switch n := read8(r); n {
32093                 case 0:
32094                         *p = false
32095                 case 1:
32096                         *p = true
32097                 default:
32098                         chk(fmt.Errorf("invalid bool: %d", n))
32099                 }
32100         }
32101         {
32102                 p := &(*(*(struct {
32103                         MaxHP            uint16 // Player only.
32104                         CollideWithNodes bool
32105                         Weight           float32 // deprecated
32106                         ColBox, SelBox   Box
32107                         Pointable        bool
32108                         Visual           string
32109                         VisualSize       [3]float32
32110                         Textures         []Texture
32111                         SpriteSheetSize  [2]int16 // in sprites.
32112                         SpritePos        [2]int16 // in sprite sheet.
32113                         Visible          bool
32114                         MakeFootstepSnds bool
32115                         RotateSpeed      float32 // in radians per second.
32116                         Mesh             string
32117                         Colors           []color.NRGBA
32118                         CollideWithAOs   bool
32119                         StepHeight       float32
32120                         FaceRotateDir    bool
32121                         FaceRotateDirOff float32 // in degrees.
32122                         BackfaceCull     bool
32123                         Nametag          string
32124                         NametagColor     color.NRGBA
32125                         FaceRotateSpeed  float32 // in degrees per second.
32126                         Infotext         string
32127                         Itemstring       string
32128                         Glow             int8
32129                         MaxBreath        uint16  // Player only.
32130                         EyeHeight        float32 // Player only.
32131                         ZoomFOV          float32 // in degrees. Player only.
32132                         UseTextureAlpha  bool
32133                         DmgTextureMod    Texture // suffix
32134                         Shaded           bool
32135                         ShowOnMinimap    bool
32136                         NametagBG        color.NRGBA
32137                 }))(obj)).ShowOnMinimap
32138                 switch n := read8(r); n {
32139                 case 0:
32140                         *p = false
32141                 case 1:
32142                         *p = true
32143                 default:
32144                         chk(fmt.Errorf("invalid bool: %d", n))
32145                 }
32146         }
32147         {
32148                 p := &(*(*(struct {
32149                         MaxHP            uint16 // Player only.
32150                         CollideWithNodes bool
32151                         Weight           float32 // deprecated
32152                         ColBox, SelBox   Box
32153                         Pointable        bool
32154                         Visual           string
32155                         VisualSize       [3]float32
32156                         Textures         []Texture
32157                         SpriteSheetSize  [2]int16 // in sprites.
32158                         SpritePos        [2]int16 // in sprite sheet.
32159                         Visible          bool
32160                         MakeFootstepSnds bool
32161                         RotateSpeed      float32 // in radians per second.
32162                         Mesh             string
32163                         Colors           []color.NRGBA
32164                         CollideWithAOs   bool
32165                         StepHeight       float32
32166                         FaceRotateDir    bool
32167                         FaceRotateDirOff float32 // in degrees.
32168                         BackfaceCull     bool
32169                         Nametag          string
32170                         NametagColor     color.NRGBA
32171                         FaceRotateSpeed  float32 // in degrees per second.
32172                         Infotext         string
32173                         Itemstring       string
32174                         Glow             int8
32175                         MaxBreath        uint16  // Player only.
32176                         EyeHeight        float32 // Player only.
32177                         ZoomFOV          float32 // in degrees. Player only.
32178                         UseTextureAlpha  bool
32179                         DmgTextureMod    Texture // suffix
32180                         Shaded           bool
32181                         ShowOnMinimap    bool
32182                         NametagBG        color.NRGBA
32183                 }))(obj)).NametagBG
32184                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
32185         }
32186 }
32187
32188 func (obj *AOPos) serialize(w io.Writer) {
32189         if err := pcall(func() {
32190                 ((*(*(struct {
32191                         Pos
32192                         Vel, Acc Vec
32193                         Rot      [3]float32
32194
32195                         Interpolate    bool
32196                         End            bool
32197                         UpdateInterval float32
32198                 }))(obj)).Pos).serialize(w)
32199         }); err != nil {
32200                 if err == io.EOF {
32201                         chk(io.EOF)
32202                 }
32203                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
32204         }
32205         if err := pcall(func() {
32206                 ((*(*(struct {
32207                         Pos
32208                         Vel, Acc Vec
32209                         Rot      [3]float32
32210
32211                         Interpolate    bool
32212                         End            bool
32213                         UpdateInterval float32
32214                 }))(obj)).Vel).serialize(w)
32215         }); err != nil {
32216                 if err == io.EOF {
32217                         chk(io.EOF)
32218                 }
32219                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32220         }
32221         if err := pcall(func() {
32222                 ((*(*(struct {
32223                         Pos
32224                         Vel, Acc Vec
32225                         Rot      [3]float32
32226
32227                         Interpolate    bool
32228                         End            bool
32229                         UpdateInterval float32
32230                 }))(obj)).Acc).serialize(w)
32231         }); err != nil {
32232                 if err == io.EOF {
32233                         chk(io.EOF)
32234                 }
32235                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32236         }
32237         for local355 := range (*(*(struct {
32238                 Pos
32239                 Vel, Acc Vec
32240                 Rot      [3]float32
32241
32242                 Interpolate    bool
32243                 End            bool
32244                 UpdateInterval float32
32245         }))(obj)).Rot {
32246                 {
32247                         x := ((*(*(struct {
32248                                 Pos
32249                                 Vel, Acc Vec
32250                                 Rot      [3]float32
32251
32252                                 Interpolate    bool
32253                                 End            bool
32254                                 UpdateInterval float32
32255                         }))(obj)).Rot)[local355]
32256                         write32(w, math.Float32bits(x))
32257                 }
32258         }
32259         {
32260                 x := (*(*(struct {
32261                         Pos
32262                         Vel, Acc Vec
32263                         Rot      [3]float32
32264
32265                         Interpolate    bool
32266                         End            bool
32267                         UpdateInterval float32
32268                 }))(obj)).Interpolate
32269                 if x {
32270                         write8(w, 1)
32271                 } else {
32272                         write8(w, 0)
32273                 }
32274         }
32275         {
32276                 x := (*(*(struct {
32277                         Pos
32278                         Vel, Acc Vec
32279                         Rot      [3]float32
32280
32281                         Interpolate    bool
32282                         End            bool
32283                         UpdateInterval float32
32284                 }))(obj)).End
32285                 if x {
32286                         write8(w, 1)
32287                 } else {
32288                         write8(w, 0)
32289                 }
32290         }
32291         {
32292                 x := (*(*(struct {
32293                         Pos
32294                         Vel, Acc Vec
32295                         Rot      [3]float32
32296
32297                         Interpolate    bool
32298                         End            bool
32299                         UpdateInterval float32
32300                 }))(obj)).UpdateInterval
32301                 write32(w, math.Float32bits(x))
32302         }
32303 }
32304
32305 func (obj *AOPos) deserialize(r io.Reader) {
32306         if err := pcall(func() {
32307                 ((*(*(struct {
32308                         Pos
32309                         Vel, Acc Vec
32310                         Rot      [3]float32
32311
32312                         Interpolate    bool
32313                         End            bool
32314                         UpdateInterval float32
32315                 }))(obj)).Pos).deserialize(r)
32316         }); err != nil {
32317                 if err == io.EOF {
32318                         chk(io.EOF)
32319                 }
32320                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
32321         }
32322         if err := pcall(func() {
32323                 ((*(*(struct {
32324                         Pos
32325                         Vel, Acc Vec
32326                         Rot      [3]float32
32327
32328                         Interpolate    bool
32329                         End            bool
32330                         UpdateInterval float32
32331                 }))(obj)).Vel).deserialize(r)
32332         }); err != nil {
32333                 if err == io.EOF {
32334                         chk(io.EOF)
32335                 }
32336                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32337         }
32338         if err := pcall(func() {
32339                 ((*(*(struct {
32340                         Pos
32341                         Vel, Acc Vec
32342                         Rot      [3]float32
32343
32344                         Interpolate    bool
32345                         End            bool
32346                         UpdateInterval float32
32347                 }))(obj)).Acc).deserialize(r)
32348         }); err != nil {
32349                 if err == io.EOF {
32350                         chk(io.EOF)
32351                 }
32352                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32353         }
32354         for local356 := range (*(*(struct {
32355                 Pos
32356                 Vel, Acc Vec
32357                 Rot      [3]float32
32358
32359                 Interpolate    bool
32360                 End            bool
32361                 UpdateInterval float32
32362         }))(obj)).Rot {
32363                 {
32364                         p := &((*(*(struct {
32365                                 Pos
32366                                 Vel, Acc Vec
32367                                 Rot      [3]float32
32368
32369                                 Interpolate    bool
32370                                 End            bool
32371                                 UpdateInterval float32
32372                         }))(obj)).Rot)[local356]
32373                         *p = math.Float32frombits(read32(r))
32374                 }
32375         }
32376         {
32377                 p := &(*(*(struct {
32378                         Pos
32379                         Vel, Acc Vec
32380                         Rot      [3]float32
32381
32382                         Interpolate    bool
32383                         End            bool
32384                         UpdateInterval float32
32385                 }))(obj)).Interpolate
32386                 switch n := read8(r); n {
32387                 case 0:
32388                         *p = false
32389                 case 1:
32390                         *p = true
32391                 default:
32392                         chk(fmt.Errorf("invalid bool: %d", n))
32393                 }
32394         }
32395         {
32396                 p := &(*(*(struct {
32397                         Pos
32398                         Vel, Acc Vec
32399                         Rot      [3]float32
32400
32401                         Interpolate    bool
32402                         End            bool
32403                         UpdateInterval float32
32404                 }))(obj)).End
32405                 switch n := read8(r); n {
32406                 case 0:
32407                         *p = false
32408                 case 1:
32409                         *p = true
32410                 default:
32411                         chk(fmt.Errorf("invalid bool: %d", n))
32412                 }
32413         }
32414         {
32415                 p := &(*(*(struct {
32416                         Pos
32417                         Vel, Acc Vec
32418                         Rot      [3]float32
32419
32420                         Interpolate    bool
32421                         End            bool
32422                         UpdateInterval float32
32423                 }))(obj)).UpdateInterval
32424                 *p = math.Float32frombits(read32(r))
32425         }
32426 }
32427
32428 func (obj *AOSprite) serialize(w io.Writer) {
32429         for local357 := range (*(*(struct {
32430                 Frame0          [2]int16
32431                 Frames          uint16
32432                 FrameDuration   float32
32433                 ViewAngleFrames bool
32434         }))(obj)).Frame0 {
32435                 {
32436                         x := ((*(*(struct {
32437                                 Frame0          [2]int16
32438                                 Frames          uint16
32439                                 FrameDuration   float32
32440                                 ViewAngleFrames bool
32441                         }))(obj)).Frame0)[local357]
32442                         write16(w, uint16(x))
32443                 }
32444         }
32445         {
32446                 x := (*(*(struct {
32447                         Frame0          [2]int16
32448                         Frames          uint16
32449                         FrameDuration   float32
32450                         ViewAngleFrames bool
32451                 }))(obj)).Frames
32452                 write16(w, uint16(x))
32453         }
32454         {
32455                 x := (*(*(struct {
32456                         Frame0          [2]int16
32457                         Frames          uint16
32458                         FrameDuration   float32
32459                         ViewAngleFrames bool
32460                 }))(obj)).FrameDuration
32461                 write32(w, math.Float32bits(x))
32462         }
32463         {
32464                 x := (*(*(struct {
32465                         Frame0          [2]int16
32466                         Frames          uint16
32467                         FrameDuration   float32
32468                         ViewAngleFrames bool
32469                 }))(obj)).ViewAngleFrames
32470                 if x {
32471                         write8(w, 1)
32472                 } else {
32473                         write8(w, 0)
32474                 }
32475         }
32476 }
32477
32478 func (obj *AOSprite) deserialize(r io.Reader) {
32479         for local358 := range (*(*(struct {
32480                 Frame0          [2]int16
32481                 Frames          uint16
32482                 FrameDuration   float32
32483                 ViewAngleFrames bool
32484         }))(obj)).Frame0 {
32485                 {
32486                         p := &((*(*(struct {
32487                                 Frame0          [2]int16
32488                                 Frames          uint16
32489                                 FrameDuration   float32
32490                                 ViewAngleFrames bool
32491                         }))(obj)).Frame0)[local358]
32492                         *p = int16(read16(r))
32493                 }
32494         }
32495         {
32496                 p := &(*(*(struct {
32497                         Frame0          [2]int16
32498                         Frames          uint16
32499                         FrameDuration   float32
32500                         ViewAngleFrames bool
32501                 }))(obj)).Frames
32502                 *p = read16(r)
32503         }
32504         {
32505                 p := &(*(*(struct {
32506                         Frame0          [2]int16
32507                         Frames          uint16
32508                         FrameDuration   float32
32509                         ViewAngleFrames bool
32510                 }))(obj)).FrameDuration
32511                 *p = math.Float32frombits(read32(r))
32512         }
32513         {
32514                 p := &(*(*(struct {
32515                         Frame0          [2]int16
32516                         Frames          uint16
32517                         FrameDuration   float32
32518                         ViewAngleFrames bool
32519                 }))(obj)).ViewAngleFrames
32520                 switch n := read8(r); n {
32521                 case 0:
32522                         *p = false
32523                 case 1:
32524                         *p = true
32525                 default:
32526                         chk(fmt.Errorf("invalid bool: %d", n))
32527                 }
32528         }
32529 }
32530
32531 func (obj *Group) serialize(w io.Writer) {
32532         if len(([]byte((*(*(struct {
32533                 Name   string
32534                 Rating int16
32535         }))(obj)).Name))) > math.MaxUint16 {
32536                 chk(ErrTooLong)
32537         }
32538         {
32539                 x := uint16(len(([]byte((*(*(struct {
32540                         Name   string
32541                         Rating int16
32542                 }))(obj)).Name))))
32543                 write16(w, uint16(x))
32544         }
32545         {
32546                 _, err := w.Write(([]byte((*(*(struct {
32547                         Name   string
32548                         Rating int16
32549                 }))(obj)).Name))[:])
32550                 chk(err)
32551         }
32552         {
32553                 x := (*(*(struct {
32554                         Name   string
32555                         Rating int16
32556                 }))(obj)).Rating
32557                 write16(w, uint16(x))
32558         }
32559 }
32560
32561 func (obj *Group) deserialize(r io.Reader) {
32562         var local359 []uint8
32563         var local360 uint16
32564         {
32565                 p := &local360
32566                 *p = read16(r)
32567         }
32568         (local359) = make([]uint8, local360)
32569         {
32570                 _, err := io.ReadFull(r, (local359)[:])
32571                 chk(err)
32572         }
32573         ((*(*(struct {
32574                 Name   string
32575                 Rating int16
32576         }))(obj)).Name) = string(local359)
32577         {
32578                 p := &(*(*(struct {
32579                         Name   string
32580                         Rating int16
32581                 }))(obj)).Rating
32582                 *p = int16(read16(r))
32583         }
32584 }
32585
32586 func (obj *AOAnim) serialize(w io.Writer) {
32587         for local361 := range (*(*(struct {
32588                 Frames [2]int32
32589                 Speed  float32
32590                 Blend  float32
32591                 NoLoop bool
32592         }))(obj)).Frames {
32593                 {
32594                         x := ((*(*(struct {
32595                                 Frames [2]int32
32596                                 Speed  float32
32597                                 Blend  float32
32598                                 NoLoop bool
32599                         }))(obj)).Frames)[local361]
32600                         write32(w, uint32(x))
32601                 }
32602         }
32603         {
32604                 x := (*(*(struct {
32605                         Frames [2]int32
32606                         Speed  float32
32607                         Blend  float32
32608                         NoLoop bool
32609                 }))(obj)).Speed
32610                 write32(w, math.Float32bits(x))
32611         }
32612         {
32613                 x := (*(*(struct {
32614                         Frames [2]int32
32615                         Speed  float32
32616                         Blend  float32
32617                         NoLoop bool
32618                 }))(obj)).Blend
32619                 write32(w, math.Float32bits(x))
32620         }
32621         {
32622                 x := (*(*(struct {
32623                         Frames [2]int32
32624                         Speed  float32
32625                         Blend  float32
32626                         NoLoop bool
32627                 }))(obj)).NoLoop
32628                 if x {
32629                         write8(w, 1)
32630                 } else {
32631                         write8(w, 0)
32632                 }
32633         }
32634 }
32635
32636 func (obj *AOAnim) deserialize(r io.Reader) {
32637         for local362 := range (*(*(struct {
32638                 Frames [2]int32
32639                 Speed  float32
32640                 Blend  float32
32641                 NoLoop bool
32642         }))(obj)).Frames {
32643                 {
32644                         p := &((*(*(struct {
32645                                 Frames [2]int32
32646                                 Speed  float32
32647                                 Blend  float32
32648                                 NoLoop bool
32649                         }))(obj)).Frames)[local362]
32650                         *p = int32(read32(r))
32651                 }
32652         }
32653         {
32654                 p := &(*(*(struct {
32655                         Frames [2]int32
32656                         Speed  float32
32657                         Blend  float32
32658                         NoLoop bool
32659                 }))(obj)).Speed
32660                 *p = math.Float32frombits(read32(r))
32661         }
32662         {
32663                 p := &(*(*(struct {
32664                         Frames [2]int32
32665                         Speed  float32
32666                         Blend  float32
32667                         NoLoop bool
32668                 }))(obj)).Blend
32669                 *p = math.Float32frombits(read32(r))
32670         }
32671         {
32672                 p := &(*(*(struct {
32673                         Frames [2]int32
32674                         Speed  float32
32675                         Blend  float32
32676                         NoLoop bool
32677                 }))(obj)).NoLoop
32678                 switch n := read8(r); n {
32679                 case 0:
32680                         *p = false
32681                 case 1:
32682                         *p = true
32683                 default:
32684                         chk(fmt.Errorf("invalid bool: %d", n))
32685                 }
32686         }
32687 }
32688
32689 func (obj *AOBonePos) serialize(w io.Writer) {
32690         if err := pcall(func() {
32691                 ((*(*(struct {
32692                         Pos Vec
32693                         Rot [3]float32
32694                 }))(obj)).Pos).serialize(w)
32695         }); err != nil {
32696                 if err == io.EOF {
32697                         chk(io.EOF)
32698                 }
32699                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32700         }
32701         for local363 := range (*(*(struct {
32702                 Pos Vec
32703                 Rot [3]float32
32704         }))(obj)).Rot {
32705                 {
32706                         x := ((*(*(struct {
32707                                 Pos Vec
32708                                 Rot [3]float32
32709                         }))(obj)).Rot)[local363]
32710                         write32(w, math.Float32bits(x))
32711                 }
32712         }
32713 }
32714
32715 func (obj *AOBonePos) deserialize(r io.Reader) {
32716         if err := pcall(func() {
32717                 ((*(*(struct {
32718                         Pos Vec
32719                         Rot [3]float32
32720                 }))(obj)).Pos).deserialize(r)
32721         }); err != nil {
32722                 if err == io.EOF {
32723                         chk(io.EOF)
32724                 }
32725                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32726         }
32727         for local364 := range (*(*(struct {
32728                 Pos Vec
32729                 Rot [3]float32
32730         }))(obj)).Rot {
32731                 {
32732                         p := &((*(*(struct {
32733                                 Pos Vec
32734                                 Rot [3]float32
32735                         }))(obj)).Rot)[local364]
32736                         *p = math.Float32frombits(read32(r))
32737                 }
32738         }
32739 }
32740
32741 func (obj *AOAttach) serialize(w io.Writer) {
32742         if err := pcall(func() {
32743                 ((*(*(struct {
32744                         ParentID     AOID
32745                         Bone         string
32746                         Pos          Vec
32747                         Rot          [3]float32
32748                         ForceVisible bool
32749                 }))(obj)).ParentID).serialize(w)
32750         }); err != nil {
32751                 if err == io.EOF {
32752                         chk(io.EOF)
32753                 }
32754                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
32755         }
32756         if len(([]byte((*(*(struct {
32757                 ParentID     AOID
32758                 Bone         string
32759                 Pos          Vec
32760                 Rot          [3]float32
32761                 ForceVisible bool
32762         }))(obj)).Bone))) > math.MaxUint16 {
32763                 chk(ErrTooLong)
32764         }
32765         {
32766                 x := uint16(len(([]byte((*(*(struct {
32767                         ParentID     AOID
32768                         Bone         string
32769                         Pos          Vec
32770                         Rot          [3]float32
32771                         ForceVisible bool
32772                 }))(obj)).Bone))))
32773                 write16(w, uint16(x))
32774         }
32775         {
32776                 _, err := w.Write(([]byte((*(*(struct {
32777                         ParentID     AOID
32778                         Bone         string
32779                         Pos          Vec
32780                         Rot          [3]float32
32781                         ForceVisible bool
32782                 }))(obj)).Bone))[:])
32783                 chk(err)
32784         }
32785         if err := pcall(func() {
32786                 ((*(*(struct {
32787                         ParentID     AOID
32788                         Bone         string
32789                         Pos          Vec
32790                         Rot          [3]float32
32791                         ForceVisible bool
32792                 }))(obj)).Pos).serialize(w)
32793         }); err != nil {
32794                 if err == io.EOF {
32795                         chk(io.EOF)
32796                 }
32797                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32798         }
32799         for local365 := range (*(*(struct {
32800                 ParentID     AOID
32801                 Bone         string
32802                 Pos          Vec
32803                 Rot          [3]float32
32804                 ForceVisible bool
32805         }))(obj)).Rot {
32806                 {
32807                         x := ((*(*(struct {
32808                                 ParentID     AOID
32809                                 Bone         string
32810                                 Pos          Vec
32811                                 Rot          [3]float32
32812                                 ForceVisible bool
32813                         }))(obj)).Rot)[local365]
32814                         write32(w, math.Float32bits(x))
32815                 }
32816         }
32817         {
32818                 x := (*(*(struct {
32819                         ParentID     AOID
32820                         Bone         string
32821                         Pos          Vec
32822                         Rot          [3]float32
32823                         ForceVisible bool
32824                 }))(obj)).ForceVisible
32825                 if x {
32826                         write8(w, 1)
32827                 } else {
32828                         write8(w, 0)
32829                 }
32830         }
32831 }
32832
32833 func (obj *AOAttach) deserialize(r io.Reader) {
32834         if err := pcall(func() {
32835                 ((*(*(struct {
32836                         ParentID     AOID
32837                         Bone         string
32838                         Pos          Vec
32839                         Rot          [3]float32
32840                         ForceVisible bool
32841                 }))(obj)).ParentID).deserialize(r)
32842         }); err != nil {
32843                 if err == io.EOF {
32844                         chk(io.EOF)
32845                 }
32846                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
32847         }
32848         var local366 []uint8
32849         var local367 uint16
32850         {
32851                 p := &local367
32852                 *p = read16(r)
32853         }
32854         (local366) = make([]uint8, local367)
32855         {
32856                 _, err := io.ReadFull(r, (local366)[:])
32857                 chk(err)
32858         }
32859         ((*(*(struct {
32860                 ParentID     AOID
32861                 Bone         string
32862                 Pos          Vec
32863                 Rot          [3]float32
32864                 ForceVisible bool
32865         }))(obj)).Bone) = string(local366)
32866         if err := pcall(func() {
32867                 ((*(*(struct {
32868                         ParentID     AOID
32869                         Bone         string
32870                         Pos          Vec
32871                         Rot          [3]float32
32872                         ForceVisible bool
32873                 }))(obj)).Pos).deserialize(r)
32874         }); err != nil {
32875                 if err == io.EOF {
32876                         chk(io.EOF)
32877                 }
32878                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32879         }
32880         for local368 := range (*(*(struct {
32881                 ParentID     AOID
32882                 Bone         string
32883                 Pos          Vec
32884                 Rot          [3]float32
32885                 ForceVisible bool
32886         }))(obj)).Rot {
32887                 {
32888                         p := &((*(*(struct {
32889                                 ParentID     AOID
32890                                 Bone         string
32891                                 Pos          Vec
32892                                 Rot          [3]float32
32893                                 ForceVisible bool
32894                         }))(obj)).Rot)[local368]
32895                         *p = math.Float32frombits(read32(r))
32896                 }
32897         }
32898         {
32899                 p := &(*(*(struct {
32900                         ParentID     AOID
32901                         Bone         string
32902                         Pos          Vec
32903                         Rot          [3]float32
32904                         ForceVisible bool
32905                 }))(obj)).ForceVisible
32906                 switch n := read8(r); n {
32907                 case 0:
32908                         *p = false
32909                 case 1:
32910                         *p = true
32911                 default:
32912                         chk(fmt.Errorf("invalid bool: %d", n))
32913                 }
32914         }
32915 }
32916
32917 func (obj *AOPhysOverride) serialize(w io.Writer) {
32918         {
32919                 x := (*(*(struct {
32920                         Walk, Jump, Gravity float32
32921
32922                         // Player only.
32923                         NoSneak, NoSneakGlitch, OldSneak bool
32924                 }))(obj)).Walk
32925                 write32(w, math.Float32bits(x))
32926         }
32927         {
32928                 x := (*(*(struct {
32929                         Walk, Jump, Gravity float32
32930
32931                         // Player only.
32932                         NoSneak, NoSneakGlitch, OldSneak bool
32933                 }))(obj)).Jump
32934                 write32(w, math.Float32bits(x))
32935         }
32936         {
32937                 x := (*(*(struct {
32938                         Walk, Jump, Gravity float32
32939
32940                         // Player only.
32941                         NoSneak, NoSneakGlitch, OldSneak bool
32942                 }))(obj)).Gravity
32943                 write32(w, math.Float32bits(x))
32944         }
32945         {
32946                 x := (*(*(struct {
32947                         Walk, Jump, Gravity float32
32948
32949                         // Player only.
32950                         NoSneak, NoSneakGlitch, OldSneak bool
32951                 }))(obj)).NoSneak
32952                 if x {
32953                         write8(w, 1)
32954                 } else {
32955                         write8(w, 0)
32956                 }
32957         }
32958         {
32959                 x := (*(*(struct {
32960                         Walk, Jump, Gravity float32
32961
32962                         // Player only.
32963                         NoSneak, NoSneakGlitch, OldSneak bool
32964                 }))(obj)).NoSneakGlitch
32965                 if x {
32966                         write8(w, 1)
32967                 } else {
32968                         write8(w, 0)
32969                 }
32970         }
32971         {
32972                 x := (*(*(struct {
32973                         Walk, Jump, Gravity float32
32974
32975                         // Player only.
32976                         NoSneak, NoSneakGlitch, OldSneak bool
32977                 }))(obj)).OldSneak
32978                 if x {
32979                         write8(w, 1)
32980                 } else {
32981                         write8(w, 0)
32982                 }
32983         }
32984 }
32985
32986 func (obj *AOPhysOverride) deserialize(r io.Reader) {
32987         {
32988                 p := &(*(*(struct {
32989                         Walk, Jump, Gravity float32
32990
32991                         // Player only.
32992                         NoSneak, NoSneakGlitch, OldSneak bool
32993                 }))(obj)).Walk
32994                 *p = math.Float32frombits(read32(r))
32995         }
32996         {
32997                 p := &(*(*(struct {
32998                         Walk, Jump, Gravity float32
32999
33000                         // Player only.
33001                         NoSneak, NoSneakGlitch, OldSneak bool
33002                 }))(obj)).Jump
33003                 *p = math.Float32frombits(read32(r))
33004         }
33005         {
33006                 p := &(*(*(struct {
33007                         Walk, Jump, Gravity float32
33008
33009                         // Player only.
33010                         NoSneak, NoSneakGlitch, OldSneak bool
33011                 }))(obj)).Gravity
33012                 *p = math.Float32frombits(read32(r))
33013         }
33014         {
33015                 p := &(*(*(struct {
33016                         Walk, Jump, Gravity float32
33017
33018                         // Player only.
33019                         NoSneak, NoSneakGlitch, OldSneak bool
33020                 }))(obj)).NoSneak
33021                 switch n := read8(r); n {
33022                 case 0:
33023                         *p = false
33024                 case 1:
33025                         *p = true
33026                 default:
33027                         chk(fmt.Errorf("invalid bool: %d", n))
33028                 }
33029         }
33030         {
33031                 p := &(*(*(struct {
33032                         Walk, Jump, Gravity float32
33033
33034                         // Player only.
33035                         NoSneak, NoSneakGlitch, OldSneak bool
33036                 }))(obj)).NoSneakGlitch
33037                 switch n := read8(r); n {
33038                 case 0:
33039                         *p = false
33040                 case 1:
33041                         *p = true
33042                 default:
33043                         chk(fmt.Errorf("invalid bool: %d", n))
33044                 }
33045         }
33046         {
33047                 p := &(*(*(struct {
33048                         Walk, Jump, Gravity float32
33049
33050                         // Player only.
33051                         NoSneak, NoSneakGlitch, OldSneak bool
33052                 }))(obj)).OldSneak
33053                 switch n := read8(r); n {
33054                 case 0:
33055                         *p = false
33056                 case 1:
33057                         *p = true
33058                 default:
33059                         chk(fmt.Errorf("invalid bool: %d", n))
33060                 }
33061         }
33062 }
33063
33064 func (obj *aoType) serialize(w io.Writer) {
33065         {
33066                 x := *(*(uint8))(obj)
33067                 write8(w, uint8(x))
33068         }
33069 }
33070
33071 func (obj *aoType) deserialize(r io.Reader) {
33072         {
33073                 p := &*(*(uint8))(obj)
33074                 *p = read8(r)
33075         }
33076 }
33077
33078 func (obj *NodeMetaField) serialize(w io.Writer) {
33079         if err := pcall(func() {
33080                 ((*(*(struct {
33081                         Field
33082                         Private bool
33083                 }))(obj)).Field).serialize(w)
33084         }); err != nil {
33085                 if err == io.EOF {
33086                         chk(io.EOF)
33087                 }
33088                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
33089         }
33090         {
33091                 x := (*(*(struct {
33092                         Field
33093                         Private bool
33094                 }))(obj)).Private
33095                 if x {
33096                         write8(w, 1)
33097                 } else {
33098                         write8(w, 0)
33099                 }
33100         }
33101 }
33102
33103 func (obj *NodeMetaField) deserialize(r io.Reader) {
33104         if err := pcall(func() {
33105                 ((*(*(struct {
33106                         Field
33107                         Private bool
33108                 }))(obj)).Field).deserialize(r)
33109         }); err != nil {
33110                 if err == io.EOF {
33111                         chk(io.EOF)
33112                 }
33113                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
33114         }
33115         {
33116                 p := &(*(*(struct {
33117                         Field
33118                         Private bool
33119                 }))(obj)).Private
33120                 switch n := read8(r); n {
33121                 case 0:
33122                         *p = false
33123                 case 1:
33124                         *p = true
33125                 default:
33126                         chk(fmt.Errorf("invalid bool: %d", n))
33127                 }
33128         }
33129 }
33130
33131 func (obj *MinimapType) serialize(w io.Writer) {
33132         {
33133                 x := *(*(uint16))(obj)
33134                 write16(w, uint16(x))
33135         }
33136 }
33137
33138 func (obj *MinimapType) deserialize(r io.Reader) {
33139         {
33140                 p := &*(*(uint16))(obj)
33141                 *p = read16(r)
33142         }
33143 }
33144
33145 func (obj *Param1Type) serialize(w io.Writer) {
33146         {
33147                 x := *(*(uint8))(obj)
33148                 write8(w, uint8(x))
33149         }
33150 }
33151
33152 func (obj *Param1Type) deserialize(r io.Reader) {
33153         {
33154                 p := &*(*(uint8))(obj)
33155                 *p = read8(r)
33156         }
33157 }
33158
33159 func (obj *Param2Type) serialize(w io.Writer) {
33160         {
33161                 x := *(*(uint8))(obj)
33162                 write8(w, uint8(x))
33163         }
33164 }
33165
33166 func (obj *Param2Type) deserialize(r io.Reader) {
33167         {
33168                 p := &*(*(uint8))(obj)
33169                 *p = read8(r)
33170         }
33171 }
33172
33173 func (obj *DrawType) serialize(w io.Writer) {
33174         {
33175                 x := *(*(uint8))(obj)
33176                 write8(w, uint8(x))
33177         }
33178 }
33179
33180 func (obj *DrawType) deserialize(r io.Reader) {
33181         {
33182                 p := &*(*(uint8))(obj)
33183                 *p = read8(r)
33184         }
33185 }
33186
33187 func (obj *TileDef) serialize(w io.Writer) {
33188         {
33189                 local369 := uint8(6)
33190                 {
33191                         x := local369
33192                         write8(w, uint8(x))
33193                 }
33194         }
33195         if err := pcall(func() {
33196                 ((*(*(struct {
33197                         Texture
33198                         Anim  TileAnim
33199                         Flags TileFlags
33200
33201                         //mt:if %s.Flags&TileColor != 0
33202                         R, G, B uint8
33203
33204                         //mt:if %s.Flags&TileScale != 0
33205                         Scale uint8
33206
33207                         //mt:if %s.Flags&TileAlign != 0
33208                         Align AlignType
33209                 }))(obj)).Texture).serialize(w)
33210         }); err != nil {
33211                 if err == io.EOF {
33212                         chk(io.EOF)
33213                 }
33214                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
33215         }
33216         if err := pcall(func() {
33217                 ((*(*(struct {
33218                         Texture
33219                         Anim  TileAnim
33220                         Flags TileFlags
33221
33222                         //mt:if %s.Flags&TileColor != 0
33223                         R, G, B uint8
33224
33225                         //mt:if %s.Flags&TileScale != 0
33226                         Scale uint8
33227
33228                         //mt:if %s.Flags&TileAlign != 0
33229                         Align AlignType
33230                 }))(obj)).Anim).serialize(w)
33231         }); err != nil {
33232                 if err == io.EOF {
33233                         chk(io.EOF)
33234                 }
33235                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
33236         }
33237         if err := pcall(func() {
33238                 ((*(*(struct {
33239                         Texture
33240                         Anim  TileAnim
33241                         Flags TileFlags
33242
33243                         //mt:if %s.Flags&TileColor != 0
33244                         R, G, B uint8
33245
33246                         //mt:if %s.Flags&TileScale != 0
33247                         Scale uint8
33248
33249                         //mt:if %s.Flags&TileAlign != 0
33250                         Align AlignType
33251                 }))(obj)).Flags).serialize(w)
33252         }); err != nil {
33253                 if err == io.EOF {
33254                         chk(io.EOF)
33255                 }
33256                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
33257         }
33258         if (*(*(struct {
33259                 Texture
33260                 Anim  TileAnim
33261                 Flags TileFlags
33262
33263                 //mt:if %s.Flags&TileColor != 0
33264                 R, G, B uint8
33265
33266                 //mt:if %s.Flags&TileScale != 0
33267                 Scale uint8
33268
33269                 //mt:if %s.Flags&TileAlign != 0
33270                 Align AlignType
33271         }))(obj)).Flags&TileColor != 0 {
33272                 {
33273                         x := (*(*(struct {
33274                                 Texture
33275                                 Anim  TileAnim
33276                                 Flags TileFlags
33277
33278                                 //mt:if %s.Flags&TileColor != 0
33279                                 R, G, B uint8
33280
33281                                 //mt:if %s.Flags&TileScale != 0
33282                                 Scale uint8
33283
33284                                 //mt:if %s.Flags&TileAlign != 0
33285                                 Align AlignType
33286                         }))(obj)).R
33287                         write8(w, uint8(x))
33288                 }
33289                 {
33290                         x := (*(*(struct {
33291                                 Texture
33292                                 Anim  TileAnim
33293                                 Flags TileFlags
33294
33295                                 //mt:if %s.Flags&TileColor != 0
33296                                 R, G, B uint8
33297
33298                                 //mt:if %s.Flags&TileScale != 0
33299                                 Scale uint8
33300
33301                                 //mt:if %s.Flags&TileAlign != 0
33302                                 Align AlignType
33303                         }))(obj)).G
33304                         write8(w, uint8(x))
33305                 }
33306                 {
33307                         x := (*(*(struct {
33308                                 Texture
33309                                 Anim  TileAnim
33310                                 Flags TileFlags
33311
33312                                 //mt:if %s.Flags&TileColor != 0
33313                                 R, G, B uint8
33314
33315                                 //mt:if %s.Flags&TileScale != 0
33316                                 Scale uint8
33317
33318                                 //mt:if %s.Flags&TileAlign != 0
33319                                 Align AlignType
33320                         }))(obj)).B
33321                         write8(w, uint8(x))
33322                 }
33323         }
33324         if (*(*(struct {
33325                 Texture
33326                 Anim  TileAnim
33327                 Flags TileFlags
33328
33329                 //mt:if %s.Flags&TileColor != 0
33330                 R, G, B uint8
33331
33332                 //mt:if %s.Flags&TileScale != 0
33333                 Scale uint8
33334
33335                 //mt:if %s.Flags&TileAlign != 0
33336                 Align AlignType
33337         }))(obj)).Flags&TileScale != 0 {
33338                 {
33339                         x := (*(*(struct {
33340                                 Texture
33341                                 Anim  TileAnim
33342                                 Flags TileFlags
33343
33344                                 //mt:if %s.Flags&TileColor != 0
33345                                 R, G, B uint8
33346
33347                                 //mt:if %s.Flags&TileScale != 0
33348                                 Scale uint8
33349
33350                                 //mt:if %s.Flags&TileAlign != 0
33351                                 Align AlignType
33352                         }))(obj)).Scale
33353                         write8(w, uint8(x))
33354                 }
33355         }
33356         if (*(*(struct {
33357                 Texture
33358                 Anim  TileAnim
33359                 Flags TileFlags
33360
33361                 //mt:if %s.Flags&TileColor != 0
33362                 R, G, B uint8
33363
33364                 //mt:if %s.Flags&TileScale != 0
33365                 Scale uint8
33366
33367                 //mt:if %s.Flags&TileAlign != 0
33368                 Align AlignType
33369         }))(obj)).Flags&TileAlign != 0 {
33370                 if err := pcall(func() {
33371                         ((*(*(struct {
33372                                 Texture
33373                                 Anim  TileAnim
33374                                 Flags TileFlags
33375
33376                                 //mt:if %s.Flags&TileColor != 0
33377                                 R, G, B uint8
33378
33379                                 //mt:if %s.Flags&TileScale != 0
33380                                 Scale uint8
33381
33382                                 //mt:if %s.Flags&TileAlign != 0
33383                                 Align AlignType
33384                         }))(obj)).Align).serialize(w)
33385                 }); err != nil {
33386                         if err == io.EOF {
33387                                 chk(io.EOF)
33388                         }
33389                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
33390                 }
33391         }
33392 }
33393
33394 func (obj *TileDef) deserialize(r io.Reader) {
33395         {
33396                 var local370 uint8
33397                 local371 := uint8(6)
33398                 {
33399                         p := &local370
33400                         *p = read8(r)
33401                 }
33402                 if local370 != local371 {
33403                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local370))
33404                 }
33405         }
33406         if err := pcall(func() {
33407                 ((*(*(struct {
33408                         Texture
33409                         Anim  TileAnim
33410                         Flags TileFlags
33411
33412                         //mt:if %s.Flags&TileColor != 0
33413                         R, G, B uint8
33414
33415                         //mt:if %s.Flags&TileScale != 0
33416                         Scale uint8
33417
33418                         //mt:if %s.Flags&TileAlign != 0
33419                         Align AlignType
33420                 }))(obj)).Texture).deserialize(r)
33421         }); err != nil {
33422                 if err == io.EOF {
33423                         chk(io.EOF)
33424                 }
33425                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
33426         }
33427         if err := pcall(func() {
33428                 ((*(*(struct {
33429                         Texture
33430                         Anim  TileAnim
33431                         Flags TileFlags
33432
33433                         //mt:if %s.Flags&TileColor != 0
33434                         R, G, B uint8
33435
33436                         //mt:if %s.Flags&TileScale != 0
33437                         Scale uint8
33438
33439                         //mt:if %s.Flags&TileAlign != 0
33440                         Align AlignType
33441                 }))(obj)).Anim).deserialize(r)
33442         }); err != nil {
33443                 if err == io.EOF {
33444                         chk(io.EOF)
33445                 }
33446                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
33447         }
33448         if err := pcall(func() {
33449                 ((*(*(struct {
33450                         Texture
33451                         Anim  TileAnim
33452                         Flags TileFlags
33453
33454                         //mt:if %s.Flags&TileColor != 0
33455                         R, G, B uint8
33456
33457                         //mt:if %s.Flags&TileScale != 0
33458                         Scale uint8
33459
33460                         //mt:if %s.Flags&TileAlign != 0
33461                         Align AlignType
33462                 }))(obj)).Flags).deserialize(r)
33463         }); err != nil {
33464                 if err == io.EOF {
33465                         chk(io.EOF)
33466                 }
33467                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
33468         }
33469         if (*(*(struct {
33470                 Texture
33471                 Anim  TileAnim
33472                 Flags TileFlags
33473
33474                 //mt:if %s.Flags&TileColor != 0
33475                 R, G, B uint8
33476
33477                 //mt:if %s.Flags&TileScale != 0
33478                 Scale uint8
33479
33480                 //mt:if %s.Flags&TileAlign != 0
33481                 Align AlignType
33482         }))(obj)).Flags&TileColor != 0 {
33483                 {
33484                         p := &(*(*(struct {
33485                                 Texture
33486                                 Anim  TileAnim
33487                                 Flags TileFlags
33488
33489                                 //mt:if %s.Flags&TileColor != 0
33490                                 R, G, B uint8
33491
33492                                 //mt:if %s.Flags&TileScale != 0
33493                                 Scale uint8
33494
33495                                 //mt:if %s.Flags&TileAlign != 0
33496                                 Align AlignType
33497                         }))(obj)).R
33498                         *p = read8(r)
33499                 }
33500                 {
33501                         p := &(*(*(struct {
33502                                 Texture
33503                                 Anim  TileAnim
33504                                 Flags TileFlags
33505
33506                                 //mt:if %s.Flags&TileColor != 0
33507                                 R, G, B uint8
33508
33509                                 //mt:if %s.Flags&TileScale != 0
33510                                 Scale uint8
33511
33512                                 //mt:if %s.Flags&TileAlign != 0
33513                                 Align AlignType
33514                         }))(obj)).G
33515                         *p = read8(r)
33516                 }
33517                 {
33518                         p := &(*(*(struct {
33519                                 Texture
33520                                 Anim  TileAnim
33521                                 Flags TileFlags
33522
33523                                 //mt:if %s.Flags&TileColor != 0
33524                                 R, G, B uint8
33525
33526                                 //mt:if %s.Flags&TileScale != 0
33527                                 Scale uint8
33528
33529                                 //mt:if %s.Flags&TileAlign != 0
33530                                 Align AlignType
33531                         }))(obj)).B
33532                         *p = read8(r)
33533                 }
33534         }
33535         if (*(*(struct {
33536                 Texture
33537                 Anim  TileAnim
33538                 Flags TileFlags
33539
33540                 //mt:if %s.Flags&TileColor != 0
33541                 R, G, B uint8
33542
33543                 //mt:if %s.Flags&TileScale != 0
33544                 Scale uint8
33545
33546                 //mt:if %s.Flags&TileAlign != 0
33547                 Align AlignType
33548         }))(obj)).Flags&TileScale != 0 {
33549                 {
33550                         p := &(*(*(struct {
33551                                 Texture
33552                                 Anim  TileAnim
33553                                 Flags TileFlags
33554
33555                                 //mt:if %s.Flags&TileColor != 0
33556                                 R, G, B uint8
33557
33558                                 //mt:if %s.Flags&TileScale != 0
33559                                 Scale uint8
33560
33561                                 //mt:if %s.Flags&TileAlign != 0
33562                                 Align AlignType
33563                         }))(obj)).Scale
33564                         *p = read8(r)
33565                 }
33566         }
33567         if (*(*(struct {
33568                 Texture
33569                 Anim  TileAnim
33570                 Flags TileFlags
33571
33572                 //mt:if %s.Flags&TileColor != 0
33573                 R, G, B uint8
33574
33575                 //mt:if %s.Flags&TileScale != 0
33576                 Scale uint8
33577
33578                 //mt:if %s.Flags&TileAlign != 0
33579                 Align AlignType
33580         }))(obj)).Flags&TileAlign != 0 {
33581                 if err := pcall(func() {
33582                         ((*(*(struct {
33583                                 Texture
33584                                 Anim  TileAnim
33585                                 Flags TileFlags
33586
33587                                 //mt:if %s.Flags&TileColor != 0
33588                                 R, G, B uint8
33589
33590                                 //mt:if %s.Flags&TileScale != 0
33591                                 Scale uint8
33592
33593                                 //mt:if %s.Flags&TileAlign != 0
33594                                 Align AlignType
33595                         }))(obj)).Align).deserialize(r)
33596                 }); err != nil {
33597                         if err == io.EOF {
33598                                 chk(io.EOF)
33599                         }
33600                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
33601                 }
33602         }
33603 }
33604
33605 func (obj *WaveType) serialize(w io.Writer) {
33606         {
33607                 x := *(*(uint8))(obj)
33608                 write8(w, uint8(x))
33609         }
33610 }
33611
33612 func (obj *WaveType) deserialize(r io.Reader) {
33613         {
33614                 p := &*(*(uint8))(obj)
33615                 *p = read8(r)
33616         }
33617 }
33618
33619 func (obj *LiquidType) serialize(w io.Writer) {
33620         {
33621                 x := *(*(uint8))(obj)
33622                 write8(w, uint8(x))
33623         }
33624 }
33625
33626 func (obj *LiquidType) deserialize(r io.Reader) {
33627         {
33628                 p := &*(*(uint8))(obj)
33629                 *p = read8(r)
33630         }
33631 }
33632
33633 func (obj *NodeBox) serialize(w io.Writer) {
33634         {
33635                 local372 := uint8(6)
33636                 {
33637                         x := local372
33638                         write8(w, uint8(x))
33639                 }
33640         }
33641         if err := pcall(func() {
33642                 ((*(*(struct {
33643                         Type NodeBoxType
33644
33645                         //mt:if %s.Type == MountedBox
33646                         WallTop, WallBot, WallSides Box
33647
33648                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33649                         Fixed []Box
33650
33651                         //mt:if %s.Type == ConnectedBox
33652                         ConnDirs, DiscoDirs  DirBoxes
33653                         DiscoAll, DiscoSides []Box
33654                 }))(obj)).Type).serialize(w)
33655         }); err != nil {
33656                 if err == io.EOF {
33657                         chk(io.EOF)
33658                 }
33659                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
33660         }
33661         if !((*(*(struct {
33662                 Type NodeBoxType
33663
33664                 //mt:if %s.Type == MountedBox
33665                 WallTop, WallBot, WallSides Box
33666
33667                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33668                 Fixed []Box
33669
33670                 //mt:if %s.Type == ConnectedBox
33671                 ConnDirs, DiscoDirs  DirBoxes
33672                 DiscoAll, DiscoSides []Box
33673         }))(obj)).Type < maxBox) {
33674                 chk(errors.New("assertion failed: %s.Type < maxBox"))
33675         }
33676         if (*(*(struct {
33677                 Type NodeBoxType
33678
33679                 //mt:if %s.Type == MountedBox
33680                 WallTop, WallBot, WallSides Box
33681
33682                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33683                 Fixed []Box
33684
33685                 //mt:if %s.Type == ConnectedBox
33686                 ConnDirs, DiscoDirs  DirBoxes
33687                 DiscoAll, DiscoSides []Box
33688         }))(obj)).Type == MountedBox {
33689                 if err := pcall(func() {
33690                         ((*(*(struct {
33691                                 Type NodeBoxType
33692
33693                                 //mt:if %s.Type == MountedBox
33694                                 WallTop, WallBot, WallSides Box
33695
33696                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33697                                 Fixed []Box
33698
33699                                 //mt:if %s.Type == ConnectedBox
33700                                 ConnDirs, DiscoDirs  DirBoxes
33701                                 DiscoAll, DiscoSides []Box
33702                         }))(obj)).WallTop).serialize(w)
33703                 }); err != nil {
33704                         if err == io.EOF {
33705                                 chk(io.EOF)
33706                         }
33707                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33708                 }
33709                 if err := pcall(func() {
33710                         ((*(*(struct {
33711                                 Type NodeBoxType
33712
33713                                 //mt:if %s.Type == MountedBox
33714                                 WallTop, WallBot, WallSides Box
33715
33716                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33717                                 Fixed []Box
33718
33719                                 //mt:if %s.Type == ConnectedBox
33720                                 ConnDirs, DiscoDirs  DirBoxes
33721                                 DiscoAll, DiscoSides []Box
33722                         }))(obj)).WallBot).serialize(w)
33723                 }); err != nil {
33724                         if err == io.EOF {
33725                                 chk(io.EOF)
33726                         }
33727                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33728                 }
33729                 if err := pcall(func() {
33730                         ((*(*(struct {
33731                                 Type NodeBoxType
33732
33733                                 //mt:if %s.Type == MountedBox
33734                                 WallTop, WallBot, WallSides Box
33735
33736                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33737                                 Fixed []Box
33738
33739                                 //mt:if %s.Type == ConnectedBox
33740                                 ConnDirs, DiscoDirs  DirBoxes
33741                                 DiscoAll, DiscoSides []Box
33742                         }))(obj)).WallSides).serialize(w)
33743                 }); err != nil {
33744                         if err == io.EOF {
33745                                 chk(io.EOF)
33746                         }
33747                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33748                 }
33749         }
33750         if t := (*(*(struct {
33751                 Type NodeBoxType
33752
33753                 //mt:if %s.Type == MountedBox
33754                 WallTop, WallBot, WallSides Box
33755
33756                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33757                 Fixed []Box
33758
33759                 //mt:if %s.Type == ConnectedBox
33760                 ConnDirs, DiscoDirs  DirBoxes
33761                 DiscoAll, DiscoSides []Box
33762         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
33763                 if len(((*(*(struct {
33764                         Type NodeBoxType
33765
33766                         //mt:if %s.Type == MountedBox
33767                         WallTop, WallBot, WallSides Box
33768
33769                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33770                         Fixed []Box
33771
33772                         //mt:if %s.Type == ConnectedBox
33773                         ConnDirs, DiscoDirs  DirBoxes
33774                         DiscoAll, DiscoSides []Box
33775                 }))(obj)).Fixed)) > math.MaxUint16 {
33776                         chk(ErrTooLong)
33777                 }
33778                 {
33779                         x := uint16(len(((*(*(struct {
33780                                 Type NodeBoxType
33781
33782                                 //mt:if %s.Type == MountedBox
33783                                 WallTop, WallBot, WallSides Box
33784
33785                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33786                                 Fixed []Box
33787
33788                                 //mt:if %s.Type == ConnectedBox
33789                                 ConnDirs, DiscoDirs  DirBoxes
33790                                 DiscoAll, DiscoSides []Box
33791                         }))(obj)).Fixed)))
33792                         write16(w, uint16(x))
33793                 }
33794                 for local373 := range (*(*(struct {
33795                         Type NodeBoxType
33796
33797                         //mt:if %s.Type == MountedBox
33798                         WallTop, WallBot, WallSides Box
33799
33800                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33801                         Fixed []Box
33802
33803                         //mt:if %s.Type == ConnectedBox
33804                         ConnDirs, DiscoDirs  DirBoxes
33805                         DiscoAll, DiscoSides []Box
33806                 }))(obj)).Fixed {
33807                         if err := pcall(func() {
33808                                 (((*(*(struct {
33809                                         Type NodeBoxType
33810
33811                                         //mt:if %s.Type == MountedBox
33812                                         WallTop, WallBot, WallSides Box
33813
33814                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33815                                         Fixed []Box
33816
33817                                         //mt:if %s.Type == ConnectedBox
33818                                         ConnDirs, DiscoDirs  DirBoxes
33819                                         DiscoAll, DiscoSides []Box
33820                                 }))(obj)).Fixed)[local373]).serialize(w)
33821                         }); err != nil {
33822                                 if err == io.EOF {
33823                                         chk(io.EOF)
33824                                 }
33825                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33826                         }
33827                 }
33828         }
33829         if (*(*(struct {
33830                 Type NodeBoxType
33831
33832                 //mt:if %s.Type == MountedBox
33833                 WallTop, WallBot, WallSides Box
33834
33835                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33836                 Fixed []Box
33837
33838                 //mt:if %s.Type == ConnectedBox
33839                 ConnDirs, DiscoDirs  DirBoxes
33840                 DiscoAll, DiscoSides []Box
33841         }))(obj)).Type == ConnectedBox {
33842                 if err := pcall(func() {
33843                         ((*(*(struct {
33844                                 Type NodeBoxType
33845
33846                                 //mt:if %s.Type == MountedBox
33847                                 WallTop, WallBot, WallSides Box
33848
33849                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33850                                 Fixed []Box
33851
33852                                 //mt:if %s.Type == ConnectedBox
33853                                 ConnDirs, DiscoDirs  DirBoxes
33854                                 DiscoAll, DiscoSides []Box
33855                         }))(obj)).ConnDirs).serialize(w)
33856                 }); err != nil {
33857                         if err == io.EOF {
33858                                 chk(io.EOF)
33859                         }
33860                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33861                 }
33862                 if err := pcall(func() {
33863                         ((*(*(struct {
33864                                 Type NodeBoxType
33865
33866                                 //mt:if %s.Type == MountedBox
33867                                 WallTop, WallBot, WallSides Box
33868
33869                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33870                                 Fixed []Box
33871
33872                                 //mt:if %s.Type == ConnectedBox
33873                                 ConnDirs, DiscoDirs  DirBoxes
33874                                 DiscoAll, DiscoSides []Box
33875                         }))(obj)).DiscoDirs).serialize(w)
33876                 }); err != nil {
33877                         if err == io.EOF {
33878                                 chk(io.EOF)
33879                         }
33880                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33881                 }
33882                 if len(((*(*(struct {
33883                         Type NodeBoxType
33884
33885                         //mt:if %s.Type == MountedBox
33886                         WallTop, WallBot, WallSides Box
33887
33888                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33889                         Fixed []Box
33890
33891                         //mt:if %s.Type == ConnectedBox
33892                         ConnDirs, DiscoDirs  DirBoxes
33893                         DiscoAll, DiscoSides []Box
33894                 }))(obj)).DiscoAll)) > math.MaxUint16 {
33895                         chk(ErrTooLong)
33896                 }
33897                 {
33898                         x := uint16(len(((*(*(struct {
33899                                 Type NodeBoxType
33900
33901                                 //mt:if %s.Type == MountedBox
33902                                 WallTop, WallBot, WallSides Box
33903
33904                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33905                                 Fixed []Box
33906
33907                                 //mt:if %s.Type == ConnectedBox
33908                                 ConnDirs, DiscoDirs  DirBoxes
33909                                 DiscoAll, DiscoSides []Box
33910                         }))(obj)).DiscoAll)))
33911                         write16(w, uint16(x))
33912                 }
33913                 for local374 := range (*(*(struct {
33914                         Type NodeBoxType
33915
33916                         //mt:if %s.Type == MountedBox
33917                         WallTop, WallBot, WallSides Box
33918
33919                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33920                         Fixed []Box
33921
33922                         //mt:if %s.Type == ConnectedBox
33923                         ConnDirs, DiscoDirs  DirBoxes
33924                         DiscoAll, DiscoSides []Box
33925                 }))(obj)).DiscoAll {
33926                         if err := pcall(func() {
33927                                 (((*(*(struct {
33928                                         Type NodeBoxType
33929
33930                                         //mt:if %s.Type == MountedBox
33931                                         WallTop, WallBot, WallSides Box
33932
33933                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33934                                         Fixed []Box
33935
33936                                         //mt:if %s.Type == ConnectedBox
33937                                         ConnDirs, DiscoDirs  DirBoxes
33938                                         DiscoAll, DiscoSides []Box
33939                                 }))(obj)).DiscoAll)[local374]).serialize(w)
33940                         }); err != nil {
33941                                 if err == io.EOF {
33942                                         chk(io.EOF)
33943                                 }
33944                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33945                         }
33946                 }
33947                 if len(((*(*(struct {
33948                         Type NodeBoxType
33949
33950                         //mt:if %s.Type == MountedBox
33951                         WallTop, WallBot, WallSides Box
33952
33953                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33954                         Fixed []Box
33955
33956                         //mt:if %s.Type == ConnectedBox
33957                         ConnDirs, DiscoDirs  DirBoxes
33958                         DiscoAll, DiscoSides []Box
33959                 }))(obj)).DiscoSides)) > math.MaxUint16 {
33960                         chk(ErrTooLong)
33961                 }
33962                 {
33963                         x := uint16(len(((*(*(struct {
33964                                 Type NodeBoxType
33965
33966                                 //mt:if %s.Type == MountedBox
33967                                 WallTop, WallBot, WallSides Box
33968
33969                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33970                                 Fixed []Box
33971
33972                                 //mt:if %s.Type == ConnectedBox
33973                                 ConnDirs, DiscoDirs  DirBoxes
33974                                 DiscoAll, DiscoSides []Box
33975                         }))(obj)).DiscoSides)))
33976                         write16(w, uint16(x))
33977                 }
33978                 for local375 := range (*(*(struct {
33979                         Type NodeBoxType
33980
33981                         //mt:if %s.Type == MountedBox
33982                         WallTop, WallBot, WallSides Box
33983
33984                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33985                         Fixed []Box
33986
33987                         //mt:if %s.Type == ConnectedBox
33988                         ConnDirs, DiscoDirs  DirBoxes
33989                         DiscoAll, DiscoSides []Box
33990                 }))(obj)).DiscoSides {
33991                         if err := pcall(func() {
33992                                 (((*(*(struct {
33993                                         Type NodeBoxType
33994
33995                                         //mt:if %s.Type == MountedBox
33996                                         WallTop, WallBot, WallSides Box
33997
33998                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33999                                         Fixed []Box
34000
34001                                         //mt:if %s.Type == ConnectedBox
34002                                         ConnDirs, DiscoDirs  DirBoxes
34003                                         DiscoAll, DiscoSides []Box
34004                                 }))(obj)).DiscoSides)[local375]).serialize(w)
34005                         }); err != nil {
34006                                 if err == io.EOF {
34007                                         chk(io.EOF)
34008                                 }
34009                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34010                         }
34011                 }
34012         }
34013 }
34014
34015 func (obj *NodeBox) deserialize(r io.Reader) {
34016         {
34017                 var local376 uint8
34018                 local377 := uint8(6)
34019                 {
34020                         p := &local376
34021                         *p = read8(r)
34022                 }
34023                 if local376 != local377 {
34024                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local376))
34025                 }
34026         }
34027         if err := pcall(func() {
34028                 ((*(*(struct {
34029                         Type NodeBoxType
34030
34031                         //mt:if %s.Type == MountedBox
34032                         WallTop, WallBot, WallSides Box
34033
34034                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34035                         Fixed []Box
34036
34037                         //mt:if %s.Type == ConnectedBox
34038                         ConnDirs, DiscoDirs  DirBoxes
34039                         DiscoAll, DiscoSides []Box
34040                 }))(obj)).Type).deserialize(r)
34041         }); err != nil {
34042                 if err == io.EOF {
34043                         chk(io.EOF)
34044                 }
34045                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
34046         }
34047         if !((*(*(struct {
34048                 Type NodeBoxType
34049
34050                 //mt:if %s.Type == MountedBox
34051                 WallTop, WallBot, WallSides Box
34052
34053                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34054                 Fixed []Box
34055
34056                 //mt:if %s.Type == ConnectedBox
34057                 ConnDirs, DiscoDirs  DirBoxes
34058                 DiscoAll, DiscoSides []Box
34059         }))(obj)).Type < maxBox) {
34060                 chk(errors.New("assertion failed: %s.Type < maxBox"))
34061         }
34062         if (*(*(struct {
34063                 Type NodeBoxType
34064
34065                 //mt:if %s.Type == MountedBox
34066                 WallTop, WallBot, WallSides Box
34067
34068                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34069                 Fixed []Box
34070
34071                 //mt:if %s.Type == ConnectedBox
34072                 ConnDirs, DiscoDirs  DirBoxes
34073                 DiscoAll, DiscoSides []Box
34074         }))(obj)).Type == MountedBox {
34075                 if err := pcall(func() {
34076                         ((*(*(struct {
34077                                 Type NodeBoxType
34078
34079                                 //mt:if %s.Type == MountedBox
34080                                 WallTop, WallBot, WallSides Box
34081
34082                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34083                                 Fixed []Box
34084
34085                                 //mt:if %s.Type == ConnectedBox
34086                                 ConnDirs, DiscoDirs  DirBoxes
34087                                 DiscoAll, DiscoSides []Box
34088                         }))(obj)).WallTop).deserialize(r)
34089                 }); err != nil {
34090                         if err == io.EOF {
34091                                 chk(io.EOF)
34092                         }
34093                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34094                 }
34095                 if err := pcall(func() {
34096                         ((*(*(struct {
34097                                 Type NodeBoxType
34098
34099                                 //mt:if %s.Type == MountedBox
34100                                 WallTop, WallBot, WallSides Box
34101
34102                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34103                                 Fixed []Box
34104
34105                                 //mt:if %s.Type == ConnectedBox
34106                                 ConnDirs, DiscoDirs  DirBoxes
34107                                 DiscoAll, DiscoSides []Box
34108                         }))(obj)).WallBot).deserialize(r)
34109                 }); err != nil {
34110                         if err == io.EOF {
34111                                 chk(io.EOF)
34112                         }
34113                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34114                 }
34115                 if err := pcall(func() {
34116                         ((*(*(struct {
34117                                 Type NodeBoxType
34118
34119                                 //mt:if %s.Type == MountedBox
34120                                 WallTop, WallBot, WallSides Box
34121
34122                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34123                                 Fixed []Box
34124
34125                                 //mt:if %s.Type == ConnectedBox
34126                                 ConnDirs, DiscoDirs  DirBoxes
34127                                 DiscoAll, DiscoSides []Box
34128                         }))(obj)).WallSides).deserialize(r)
34129                 }); err != nil {
34130                         if err == io.EOF {
34131                                 chk(io.EOF)
34132                         }
34133                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34134                 }
34135         }
34136         if t := (*(*(struct {
34137                 Type NodeBoxType
34138
34139                 //mt:if %s.Type == MountedBox
34140                 WallTop, WallBot, WallSides Box
34141
34142                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34143                 Fixed []Box
34144
34145                 //mt:if %s.Type == ConnectedBox
34146                 ConnDirs, DiscoDirs  DirBoxes
34147                 DiscoAll, DiscoSides []Box
34148         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
34149                 var local378 uint16
34150                 {
34151                         p := &local378
34152                         *p = read16(r)
34153                 }
34154                 ((*(*(struct {
34155                         Type NodeBoxType
34156
34157                         //mt:if %s.Type == MountedBox
34158                         WallTop, WallBot, WallSides Box
34159
34160                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34161                         Fixed []Box
34162
34163                         //mt:if %s.Type == ConnectedBox
34164                         ConnDirs, DiscoDirs  DirBoxes
34165                         DiscoAll, DiscoSides []Box
34166                 }))(obj)).Fixed) = make([]Box, local378)
34167                 for local379 := range (*(*(struct {
34168                         Type NodeBoxType
34169
34170                         //mt:if %s.Type == MountedBox
34171                         WallTop, WallBot, WallSides Box
34172
34173                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34174                         Fixed []Box
34175
34176                         //mt:if %s.Type == ConnectedBox
34177                         ConnDirs, DiscoDirs  DirBoxes
34178                         DiscoAll, DiscoSides []Box
34179                 }))(obj)).Fixed {
34180                         if err := pcall(func() {
34181                                 (((*(*(struct {
34182                                         Type NodeBoxType
34183
34184                                         //mt:if %s.Type == MountedBox
34185                                         WallTop, WallBot, WallSides Box
34186
34187                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34188                                         Fixed []Box
34189
34190                                         //mt:if %s.Type == ConnectedBox
34191                                         ConnDirs, DiscoDirs  DirBoxes
34192                                         DiscoAll, DiscoSides []Box
34193                                 }))(obj)).Fixed)[local379]).deserialize(r)
34194                         }); err != nil {
34195                                 if err == io.EOF {
34196                                         chk(io.EOF)
34197                                 }
34198                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34199                         }
34200                 }
34201         }
34202         if (*(*(struct {
34203                 Type NodeBoxType
34204
34205                 //mt:if %s.Type == MountedBox
34206                 WallTop, WallBot, WallSides Box
34207
34208                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34209                 Fixed []Box
34210
34211                 //mt:if %s.Type == ConnectedBox
34212                 ConnDirs, DiscoDirs  DirBoxes
34213                 DiscoAll, DiscoSides []Box
34214         }))(obj)).Type == ConnectedBox {
34215                 if err := pcall(func() {
34216                         ((*(*(struct {
34217                                 Type NodeBoxType
34218
34219                                 //mt:if %s.Type == MountedBox
34220                                 WallTop, WallBot, WallSides Box
34221
34222                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34223                                 Fixed []Box
34224
34225                                 //mt:if %s.Type == ConnectedBox
34226                                 ConnDirs, DiscoDirs  DirBoxes
34227                                 DiscoAll, DiscoSides []Box
34228                         }))(obj)).ConnDirs).deserialize(r)
34229                 }); err != nil {
34230                         if err == io.EOF {
34231                                 chk(io.EOF)
34232                         }
34233                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
34234                 }
34235                 if err := pcall(func() {
34236                         ((*(*(struct {
34237                                 Type NodeBoxType
34238
34239                                 //mt:if %s.Type == MountedBox
34240                                 WallTop, WallBot, WallSides Box
34241
34242                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34243                                 Fixed []Box
34244
34245                                 //mt:if %s.Type == ConnectedBox
34246                                 ConnDirs, DiscoDirs  DirBoxes
34247                                 DiscoAll, DiscoSides []Box
34248                         }))(obj)).DiscoDirs).deserialize(r)
34249                 }); err != nil {
34250                         if err == io.EOF {
34251                                 chk(io.EOF)
34252                         }
34253                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
34254                 }
34255                 var local380 uint16
34256                 {
34257                         p := &local380
34258                         *p = read16(r)
34259                 }
34260                 ((*(*(struct {
34261                         Type NodeBoxType
34262
34263                         //mt:if %s.Type == MountedBox
34264                         WallTop, WallBot, WallSides Box
34265
34266                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34267                         Fixed []Box
34268
34269                         //mt:if %s.Type == ConnectedBox
34270                         ConnDirs, DiscoDirs  DirBoxes
34271                         DiscoAll, DiscoSides []Box
34272                 }))(obj)).DiscoAll) = make([]Box, local380)
34273                 for local381 := range (*(*(struct {
34274                         Type NodeBoxType
34275
34276                         //mt:if %s.Type == MountedBox
34277                         WallTop, WallBot, WallSides Box
34278
34279                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34280                         Fixed []Box
34281
34282                         //mt:if %s.Type == ConnectedBox
34283                         ConnDirs, DiscoDirs  DirBoxes
34284                         DiscoAll, DiscoSides []Box
34285                 }))(obj)).DiscoAll {
34286                         if err := pcall(func() {
34287                                 (((*(*(struct {
34288                                         Type NodeBoxType
34289
34290                                         //mt:if %s.Type == MountedBox
34291                                         WallTop, WallBot, WallSides Box
34292
34293                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34294                                         Fixed []Box
34295
34296                                         //mt:if %s.Type == ConnectedBox
34297                                         ConnDirs, DiscoDirs  DirBoxes
34298                                         DiscoAll, DiscoSides []Box
34299                                 }))(obj)).DiscoAll)[local381]).deserialize(r)
34300                         }); err != nil {
34301                                 if err == io.EOF {
34302                                         chk(io.EOF)
34303                                 }
34304                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34305                         }
34306                 }
34307                 var local382 uint16
34308                 {
34309                         p := &local382
34310                         *p = read16(r)
34311                 }
34312                 ((*(*(struct {
34313                         Type NodeBoxType
34314
34315                         //mt:if %s.Type == MountedBox
34316                         WallTop, WallBot, WallSides Box
34317
34318                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34319                         Fixed []Box
34320
34321                         //mt:if %s.Type == ConnectedBox
34322                         ConnDirs, DiscoDirs  DirBoxes
34323                         DiscoAll, DiscoSides []Box
34324                 }))(obj)).DiscoSides) = make([]Box, local382)
34325                 for local383 := range (*(*(struct {
34326                         Type NodeBoxType
34327
34328                         //mt:if %s.Type == MountedBox
34329                         WallTop, WallBot, WallSides Box
34330
34331                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34332                         Fixed []Box
34333
34334                         //mt:if %s.Type == ConnectedBox
34335                         ConnDirs, DiscoDirs  DirBoxes
34336                         DiscoAll, DiscoSides []Box
34337                 }))(obj)).DiscoSides {
34338                         if err := pcall(func() {
34339                                 (((*(*(struct {
34340                                         Type NodeBoxType
34341
34342                                         //mt:if %s.Type == MountedBox
34343                                         WallTop, WallBot, WallSides Box
34344
34345                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34346                                         Fixed []Box
34347
34348                                         //mt:if %s.Type == ConnectedBox
34349                                         ConnDirs, DiscoDirs  DirBoxes
34350                                         DiscoAll, DiscoSides []Box
34351                                 }))(obj)).DiscoSides)[local383]).deserialize(r)
34352                         }); err != nil {
34353                                 if err == io.EOF {
34354                                         chk(io.EOF)
34355                                 }
34356                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34357                         }
34358                 }
34359         }
34360 }
34361
34362 func (obj *SoundDef) serialize(w io.Writer) {
34363         if len(([]byte((*(*(struct {
34364                 Name              string
34365                 Gain, Pitch, Fade float32
34366         }))(obj)).Name))) > math.MaxUint16 {
34367                 chk(ErrTooLong)
34368         }
34369         {
34370                 x := uint16(len(([]byte((*(*(struct {
34371                         Name              string
34372                         Gain, Pitch, Fade float32
34373                 }))(obj)).Name))))
34374                 write16(w, uint16(x))
34375         }
34376         {
34377                 _, err := w.Write(([]byte((*(*(struct {
34378                         Name              string
34379                         Gain, Pitch, Fade float32
34380                 }))(obj)).Name))[:])
34381                 chk(err)
34382         }
34383         {
34384                 x := (*(*(struct {
34385                         Name              string
34386                         Gain, Pitch, Fade float32
34387                 }))(obj)).Gain
34388                 write32(w, math.Float32bits(x))
34389         }
34390         {
34391                 x := (*(*(struct {
34392                         Name              string
34393                         Gain, Pitch, Fade float32
34394                 }))(obj)).Pitch
34395                 write32(w, math.Float32bits(x))
34396         }
34397         {
34398                 x := (*(*(struct {
34399                         Name              string
34400                         Gain, Pitch, Fade float32
34401                 }))(obj)).Fade
34402                 write32(w, math.Float32bits(x))
34403         }
34404 }
34405
34406 func (obj *SoundDef) deserialize(r io.Reader) {
34407         var local384 []uint8
34408         var local385 uint16
34409         {
34410                 p := &local385
34411                 *p = read16(r)
34412         }
34413         (local384) = make([]uint8, local385)
34414         {
34415                 _, err := io.ReadFull(r, (local384)[:])
34416                 chk(err)
34417         }
34418         ((*(*(struct {
34419                 Name              string
34420                 Gain, Pitch, Fade float32
34421         }))(obj)).Name) = string(local384)
34422         {
34423                 p := &(*(*(struct {
34424                         Name              string
34425                         Gain, Pitch, Fade float32
34426                 }))(obj)).Gain
34427                 *p = math.Float32frombits(read32(r))
34428         }
34429         {
34430                 p := &(*(*(struct {
34431                         Name              string
34432                         Gain, Pitch, Fade float32
34433                 }))(obj)).Pitch
34434                 *p = math.Float32frombits(read32(r))
34435         }
34436         {
34437                 p := &(*(*(struct {
34438                         Name              string
34439                         Gain, Pitch, Fade float32
34440                 }))(obj)).Fade
34441                 *p = math.Float32frombits(read32(r))
34442         }
34443 }
34444
34445 func (obj *AlphaUse) serialize(w io.Writer) {
34446         {
34447                 x := *(*(uint8))(obj)
34448                 write8(w, uint8(x))
34449         }
34450 }
34451
34452 func (obj *AlphaUse) deserialize(r io.Reader) {
34453         {
34454                 p := &*(*(uint8))(obj)
34455                 *p = read8(r)
34456         }
34457 }
34458
34459 func (obj *Keys) serialize(w io.Writer) {
34460         {
34461                 x := *(*(uint32))(obj)
34462                 write32(w, uint32(x))
34463         }
34464 }
34465
34466 func (obj *Keys) deserialize(r io.Reader) {
34467         {
34468                 p := &*(*(uint32))(obj)
34469                 *p = read32(r)
34470         }
34471 }
34472
34473 func (obj *MapBlkFlags) serialize(w io.Writer) {
34474         {
34475                 x := *(*(uint8))(obj)
34476                 write8(w, uint8(x))
34477         }
34478 }
34479
34480 func (obj *MapBlkFlags) deserialize(r io.Reader) {
34481         {
34482                 p := &*(*(uint8))(obj)
34483                 *p = read8(r)
34484         }
34485 }
34486
34487 func (obj *LitFromBlks) serialize(w io.Writer) {
34488         {
34489                 x := *(*(uint16))(obj)
34490                 write16(w, uint16(x))
34491         }
34492 }
34493
34494 func (obj *LitFromBlks) deserialize(r io.Reader) {
34495         {
34496                 p := &*(*(uint16))(obj)
34497                 *p = read16(r)
34498         }
34499 }
34500
34501 func (obj *AOInitData) serialize(w io.Writer) {
34502         {
34503                 local386 := uint8(1)
34504                 {
34505                         x := local386
34506                         write8(w, uint8(x))
34507                 }
34508         }
34509         if len(([]byte((*(*(struct {
34510
34511                 // For players.
34512                 Name     string
34513                 IsPlayer bool
34514
34515                 ID AOID
34516
34517                 Pos
34518                 Rot [3]float32
34519
34520                 HP uint16
34521
34522                 // See (de)serialize.fmt.
34523                 Msgs []AOMsg
34524         }))(obj)).Name))) > math.MaxUint16 {
34525                 chk(ErrTooLong)
34526         }
34527         {
34528                 x := uint16(len(([]byte((*(*(struct {
34529
34530                         // For players.
34531                         Name     string
34532                         IsPlayer bool
34533
34534                         ID AOID
34535
34536                         Pos
34537                         Rot [3]float32
34538
34539                         HP uint16
34540
34541                         // See (de)serialize.fmt.
34542                         Msgs []AOMsg
34543                 }))(obj)).Name))))
34544                 write16(w, uint16(x))
34545         }
34546         {
34547                 _, err := w.Write(([]byte((*(*(struct {
34548
34549                         // For players.
34550                         Name     string
34551                         IsPlayer bool
34552
34553                         ID AOID
34554
34555                         Pos
34556                         Rot [3]float32
34557
34558                         HP uint16
34559
34560                         // See (de)serialize.fmt.
34561                         Msgs []AOMsg
34562                 }))(obj)).Name))[:])
34563                 chk(err)
34564         }
34565         {
34566                 x := (*(*(struct {
34567
34568                         // For players.
34569                         Name     string
34570                         IsPlayer bool
34571
34572                         ID AOID
34573
34574                         Pos
34575                         Rot [3]float32
34576
34577                         HP uint16
34578
34579                         // See (de)serialize.fmt.
34580                         Msgs []AOMsg
34581                 }))(obj)).IsPlayer
34582                 if x {
34583                         write8(w, 1)
34584                 } else {
34585                         write8(w, 0)
34586                 }
34587         }
34588         if err := pcall(func() {
34589                 ((*(*(struct {
34590
34591                         // For players.
34592                         Name     string
34593                         IsPlayer bool
34594
34595                         ID AOID
34596
34597                         Pos
34598                         Rot [3]float32
34599
34600                         HP uint16
34601
34602                         // See (de)serialize.fmt.
34603                         Msgs []AOMsg
34604                 }))(obj)).ID).serialize(w)
34605         }); err != nil {
34606                 if err == io.EOF {
34607                         chk(io.EOF)
34608                 }
34609                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
34610         }
34611         if err := pcall(func() {
34612                 ((*(*(struct {
34613
34614                         // For players.
34615                         Name     string
34616                         IsPlayer bool
34617
34618                         ID AOID
34619
34620                         Pos
34621                         Rot [3]float32
34622
34623                         HP uint16
34624
34625                         // See (de)serialize.fmt.
34626                         Msgs []AOMsg
34627                 }))(obj)).Pos).serialize(w)
34628         }); err != nil {
34629                 if err == io.EOF {
34630                         chk(io.EOF)
34631                 }
34632                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
34633         }
34634         for local387 := range (*(*(struct {
34635
34636                 // For players.
34637                 Name     string
34638                 IsPlayer bool
34639
34640                 ID AOID
34641
34642                 Pos
34643                 Rot [3]float32
34644
34645                 HP uint16
34646
34647                 // See (de)serialize.fmt.
34648                 Msgs []AOMsg
34649         }))(obj)).Rot {
34650                 {
34651                         x := ((*(*(struct {
34652
34653                                 // For players.
34654                                 Name     string
34655                                 IsPlayer bool
34656
34657                                 ID AOID
34658
34659                                 Pos
34660                                 Rot [3]float32
34661
34662                                 HP uint16
34663
34664                                 // See (de)serialize.fmt.
34665                                 Msgs []AOMsg
34666                         }))(obj)).Rot)[local387]
34667                         write32(w, math.Float32bits(x))
34668                 }
34669         }
34670         {
34671                 x := (*(*(struct {
34672
34673                         // For players.
34674                         Name     string
34675                         IsPlayer bool
34676
34677                         ID AOID
34678
34679                         Pos
34680                         Rot [3]float32
34681
34682                         HP uint16
34683
34684                         // See (de)serialize.fmt.
34685                         Msgs []AOMsg
34686                 }))(obj)).HP
34687                 write16(w, uint16(x))
34688         }
34689         {
34690                 x := (*(*(struct {
34691
34692                         // For players.
34693                         Name     string
34694                         IsPlayer bool
34695
34696                         ID AOID
34697
34698                         Pos
34699                         Rot [3]float32
34700
34701                         HP uint16
34702
34703                         // See (de)serialize.fmt.
34704                         Msgs []AOMsg
34705                 }))(obj)).Msgs
34706                 { // For AOInitData.Msgs.
34707                         if len(x) > math.MaxUint8 {
34708                                 chk(ErrTooLong)
34709                         }
34710                         write8(w, uint8(len(x)))
34711                         for _, msg := range x {
34712                                 var b bytes.Buffer
34713                                 chk(writeAOMsg(&b, msg))
34714                                 if b.Len() > math.MaxUint32 {
34715                                         chk(ErrTooLong)
34716                                 }
34717                                 write32(w, uint32(b.Len()))
34718                                 _, err := b.WriteTo(w)
34719                                 chk(err)
34720                         }
34721                 }
34722         }
34723 }
34724
34725 func (obj *AOInitData) deserialize(r io.Reader) {
34726         {
34727                 var local388 uint8
34728                 local389 := uint8(1)
34729                 {
34730                         p := &local388
34731                         *p = read8(r)
34732                 }
34733                 if local388 != local389 {
34734                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local388))
34735                 }
34736         }
34737         var local390 []uint8
34738         var local391 uint16
34739         {
34740                 p := &local391
34741                 *p = read16(r)
34742         }
34743         (local390) = make([]uint8, local391)
34744         {
34745                 _, err := io.ReadFull(r, (local390)[:])
34746                 chk(err)
34747         }
34748         ((*(*(struct {
34749
34750                 // For players.
34751                 Name     string
34752                 IsPlayer bool
34753
34754                 ID AOID
34755
34756                 Pos
34757                 Rot [3]float32
34758
34759                 HP uint16
34760
34761                 // See (de)serialize.fmt.
34762                 Msgs []AOMsg
34763         }))(obj)).Name) = string(local390)
34764         {
34765                 p := &(*(*(struct {
34766
34767                         // For players.
34768                         Name     string
34769                         IsPlayer bool
34770
34771                         ID AOID
34772
34773                         Pos
34774                         Rot [3]float32
34775
34776                         HP uint16
34777
34778                         // See (de)serialize.fmt.
34779                         Msgs []AOMsg
34780                 }))(obj)).IsPlayer
34781                 switch n := read8(r); n {
34782                 case 0:
34783                         *p = false
34784                 case 1:
34785                         *p = true
34786                 default:
34787                         chk(fmt.Errorf("invalid bool: %d", n))
34788                 }
34789         }
34790         if err := pcall(func() {
34791                 ((*(*(struct {
34792
34793                         // For players.
34794                         Name     string
34795                         IsPlayer bool
34796
34797                         ID AOID
34798
34799                         Pos
34800                         Rot [3]float32
34801
34802                         HP uint16
34803
34804                         // See (de)serialize.fmt.
34805                         Msgs []AOMsg
34806                 }))(obj)).ID).deserialize(r)
34807         }); err != nil {
34808                 if err == io.EOF {
34809                         chk(io.EOF)
34810                 }
34811                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
34812         }
34813         if err := pcall(func() {
34814                 ((*(*(struct {
34815
34816                         // For players.
34817                         Name     string
34818                         IsPlayer bool
34819
34820                         ID AOID
34821
34822                         Pos
34823                         Rot [3]float32
34824
34825                         HP uint16
34826
34827                         // See (de)serialize.fmt.
34828                         Msgs []AOMsg
34829                 }))(obj)).Pos).deserialize(r)
34830         }); err != nil {
34831                 if err == io.EOF {
34832                         chk(io.EOF)
34833                 }
34834                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
34835         }
34836         for local392 := range (*(*(struct {
34837
34838                 // For players.
34839                 Name     string
34840                 IsPlayer bool
34841
34842                 ID AOID
34843
34844                 Pos
34845                 Rot [3]float32
34846
34847                 HP uint16
34848
34849                 // See (de)serialize.fmt.
34850                 Msgs []AOMsg
34851         }))(obj)).Rot {
34852                 {
34853                         p := &((*(*(struct {
34854
34855                                 // For players.
34856                                 Name     string
34857                                 IsPlayer bool
34858
34859                                 ID AOID
34860
34861                                 Pos
34862                                 Rot [3]float32
34863
34864                                 HP uint16
34865
34866                                 // See (de)serialize.fmt.
34867                                 Msgs []AOMsg
34868                         }))(obj)).Rot)[local392]
34869                         *p = math.Float32frombits(read32(r))
34870                 }
34871         }
34872         {
34873                 p := &(*(*(struct {
34874
34875                         // For players.
34876                         Name     string
34877                         IsPlayer bool
34878
34879                         ID AOID
34880
34881                         Pos
34882                         Rot [3]float32
34883
34884                         HP uint16
34885
34886                         // See (de)serialize.fmt.
34887                         Msgs []AOMsg
34888                 }))(obj)).HP
34889                 *p = read16(r)
34890         }
34891         {
34892                 p := &(*(*(struct {
34893
34894                         // For players.
34895                         Name     string
34896                         IsPlayer bool
34897
34898                         ID AOID
34899
34900                         Pos
34901                         Rot [3]float32
34902
34903                         HP uint16
34904
34905                         // See (de)serialize.fmt.
34906                         Msgs []AOMsg
34907                 }))(obj)).Msgs
34908                 { // For AOInitData.Msgs.
34909                         *p = make([]AOMsg, read8(r))
34910                         for i := range *p {
34911                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
34912                                 msg, err := readAOMsg(r)
34913                                 chk(err)
34914                                 (*p)[i] = msg
34915                                 if r.N > 0 {
34916                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34917                                 }
34918                         }
34919                 }
34920         }
34921 }
34922
34923 func (obj *ItemType) serialize(w io.Writer) {
34924         {
34925                 x := *(*(uint8))(obj)
34926                 write8(w, uint8(x))
34927         }
34928 }
34929
34930 func (obj *ItemType) deserialize(r io.Reader) {
34931         {
34932                 p := &*(*(uint8))(obj)
34933                 *p = read8(r)
34934         }
34935 }
34936
34937 func (obj *ToolCaps) serialize(w io.Writer) {
34938         if _ = (*(*(struct {
34939                 //mt:if _ = %s; false
34940                 NonNil bool
34941
34942                 AttackCooldown float32
34943                 MaxDropLvl     int16
34944
34945                 //mt:len32
34946                 GroupCaps []ToolGroupCap
34947
34948                 //mt:len32
34949                 DmgGroups []Group
34950
34951                 //mt:32tou16
34952                 PunchUses int32
34953         }))(obj)); false {
34954                 {
34955                         x := (*(*(struct {
34956                                 //mt:if _ = %s; false
34957                                 NonNil bool
34958
34959                                 AttackCooldown float32
34960                                 MaxDropLvl     int16
34961
34962                                 //mt:len32
34963                                 GroupCaps []ToolGroupCap
34964
34965                                 //mt:len32
34966                                 DmgGroups []Group
34967
34968                                 //mt:32tou16
34969                                 PunchUses int32
34970                         }))(obj)).NonNil
34971                         if x {
34972                                 write8(w, 1)
34973                         } else {
34974                                 write8(w, 0)
34975                         }
34976                 }
34977         }
34978         {
34979                 ow := w
34980                 w := new(bytes.Buffer)
34981                 /*
34982                    if r.N > 0 { (*(*(struct {
34983                         //mt:if _ = %s; false
34984                         NonNil  bool
34985
34986                         AttackCooldown  float32
34987                         MaxDropLvl      int16
34988
34989                         //mt:len32
34990                         GroupCaps       []ToolGroupCap
34991
34992                         //mt:len32
34993                         DmgGroups       []Group
34994
34995                         //mt:32tou16
34996                         PunchUses       int32
34997                    }))(obj)).NonNil = true}; /**/{
34998                         if (*(*(struct {
34999                                 //mt:if _ = %s; false
35000                                 NonNil bool
35001
35002                                 AttackCooldown float32
35003                                 MaxDropLvl     int16
35004
35005                                 //mt:len32
35006                                 GroupCaps []ToolGroupCap
35007
35008                                 //mt:len32
35009                                 DmgGroups []Group
35010
35011                                 //mt:32tou16
35012                                 PunchUses int32
35013                         }))(obj)).NonNil {
35014                                 {
35015                                         local393 := uint8(5)
35016                                         {
35017                                                 x := local393
35018                                                 write8(w, uint8(x))
35019                                         }
35020                                 }
35021                                 {
35022                                         x := (*(*(struct {
35023                                                 //mt:if _ = %s; false
35024                                                 NonNil bool
35025
35026                                                 AttackCooldown float32
35027                                                 MaxDropLvl     int16
35028
35029                                                 //mt:len32
35030                                                 GroupCaps []ToolGroupCap
35031
35032                                                 //mt:len32
35033                                                 DmgGroups []Group
35034
35035                                                 //mt:32tou16
35036                                                 PunchUses int32
35037                                         }))(obj)).AttackCooldown
35038                                         write32(w, math.Float32bits(x))
35039                                 }
35040                                 {
35041                                         x := (*(*(struct {
35042                                                 //mt:if _ = %s; false
35043                                                 NonNil bool
35044
35045                                                 AttackCooldown float32
35046                                                 MaxDropLvl     int16
35047
35048                                                 //mt:len32
35049                                                 GroupCaps []ToolGroupCap
35050
35051                                                 //mt:len32
35052                                                 DmgGroups []Group
35053
35054                                                 //mt:32tou16
35055                                                 PunchUses int32
35056                                         }))(obj)).MaxDropLvl
35057                                         write16(w, uint16(x))
35058                                 }
35059                                 if len(((*(*(struct {
35060                                         //mt:if _ = %s; false
35061                                         NonNil bool
35062
35063                                         AttackCooldown float32
35064                                         MaxDropLvl     int16
35065
35066                                         //mt:len32
35067                                         GroupCaps []ToolGroupCap
35068
35069                                         //mt:len32
35070                                         DmgGroups []Group
35071
35072                                         //mt:32tou16
35073                                         PunchUses int32
35074                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
35075                                         chk(ErrTooLong)
35076                                 }
35077                                 {
35078                                         x := uint32(len(((*(*(struct {
35079                                                 //mt:if _ = %s; false
35080                                                 NonNil bool
35081
35082                                                 AttackCooldown float32
35083                                                 MaxDropLvl     int16
35084
35085                                                 //mt:len32
35086                                                 GroupCaps []ToolGroupCap
35087
35088                                                 //mt:len32
35089                                                 DmgGroups []Group
35090
35091                                                 //mt:32tou16
35092                                                 PunchUses int32
35093                                         }))(obj)).GroupCaps)))
35094                                         write32(w, uint32(x))
35095                                 }
35096                                 for local394 := range (*(*(struct {
35097                                         //mt:if _ = %s; false
35098                                         NonNil bool
35099
35100                                         AttackCooldown float32
35101                                         MaxDropLvl     int16
35102
35103                                         //mt:len32
35104                                         GroupCaps []ToolGroupCap
35105
35106                                         //mt:len32
35107                                         DmgGroups []Group
35108
35109                                         //mt:32tou16
35110                                         PunchUses int32
35111                                 }))(obj)).GroupCaps {
35112                                         if err := pcall(func() {
35113                                                 (((*(*(struct {
35114                                                         //mt:if _ = %s; false
35115                                                         NonNil bool
35116
35117                                                         AttackCooldown float32
35118                                                         MaxDropLvl     int16
35119
35120                                                         //mt:len32
35121                                                         GroupCaps []ToolGroupCap
35122
35123                                                         //mt:len32
35124                                                         DmgGroups []Group
35125
35126                                                         //mt:32tou16
35127                                                         PunchUses int32
35128                                                 }))(obj)).GroupCaps)[local394]).serialize(w)
35129                                         }); err != nil {
35130                                                 if err == io.EOF {
35131                                                         chk(io.EOF)
35132                                                 }
35133                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
35134                                         }
35135                                 }
35136                                 if len(((*(*(struct {
35137                                         //mt:if _ = %s; false
35138                                         NonNil bool
35139
35140                                         AttackCooldown float32
35141                                         MaxDropLvl     int16
35142
35143                                         //mt:len32
35144                                         GroupCaps []ToolGroupCap
35145
35146                                         //mt:len32
35147                                         DmgGroups []Group
35148
35149                                         //mt:32tou16
35150                                         PunchUses int32
35151                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
35152                                         chk(ErrTooLong)
35153                                 }
35154                                 {
35155                                         x := uint32(len(((*(*(struct {
35156                                                 //mt:if _ = %s; false
35157                                                 NonNil bool
35158
35159                                                 AttackCooldown float32
35160                                                 MaxDropLvl     int16
35161
35162                                                 //mt:len32
35163                                                 GroupCaps []ToolGroupCap
35164
35165                                                 //mt:len32
35166                                                 DmgGroups []Group
35167
35168                                                 //mt:32tou16
35169                                                 PunchUses int32
35170                                         }))(obj)).DmgGroups)))
35171                                         write32(w, uint32(x))
35172                                 }
35173                                 for local395 := range (*(*(struct {
35174                                         //mt:if _ = %s; false
35175                                         NonNil bool
35176
35177                                         AttackCooldown float32
35178                                         MaxDropLvl     int16
35179
35180                                         //mt:len32
35181                                         GroupCaps []ToolGroupCap
35182
35183                                         //mt:len32
35184                                         DmgGroups []Group
35185
35186                                         //mt:32tou16
35187                                         PunchUses int32
35188                                 }))(obj)).DmgGroups {
35189                                         if err := pcall(func() {
35190                                                 (((*(*(struct {
35191                                                         //mt:if _ = %s; false
35192                                                         NonNil bool
35193
35194                                                         AttackCooldown float32
35195                                                         MaxDropLvl     int16
35196
35197                                                         //mt:len32
35198                                                         GroupCaps []ToolGroupCap
35199
35200                                                         //mt:len32
35201                                                         DmgGroups []Group
35202
35203                                                         //mt:32tou16
35204                                                         PunchUses int32
35205                                                 }))(obj)).DmgGroups)[local395]).serialize(w)
35206                                         }); err != nil {
35207                                                 if err == io.EOF {
35208                                                         chk(io.EOF)
35209                                                 }
35210                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
35211                                         }
35212                                 }
35213                                 {
35214                                         x := uint16((*(*(struct {
35215                                                 //mt:if _ = %s; false
35216                                                 NonNil bool
35217
35218                                                 AttackCooldown float32
35219                                                 MaxDropLvl     int16
35220
35221                                                 //mt:len32
35222                                                 GroupCaps []ToolGroupCap
35223
35224                                                 //mt:len32
35225                                                 DmgGroups []Group
35226
35227                                                 //mt:32tou16
35228                                                 PunchUses int32
35229                                         }))(obj)).PunchUses)
35230                                         write16(w, uint16(x))
35231                                 }
35232                         }
35233                 }
35234                 {
35235                         buf := w
35236                         w := ow
35237                         if len((buf.Bytes())) > math.MaxUint16 {
35238                                 chk(ErrTooLong)
35239                         }
35240                         {
35241                                 x := uint16(len((buf.Bytes())))
35242                                 write16(w, uint16(x))
35243                         }
35244                         {
35245                                 _, err := w.Write((buf.Bytes())[:])
35246                                 chk(err)
35247                         }
35248                 }
35249         }
35250 }
35251
35252 func (obj *ToolCaps) deserialize(r io.Reader) {
35253         if _ = (*(*(struct {
35254                 //mt:if _ = %s; false
35255                 NonNil bool
35256
35257                 AttackCooldown float32
35258                 MaxDropLvl     int16
35259
35260                 //mt:len32
35261                 GroupCaps []ToolGroupCap
35262
35263                 //mt:len32
35264                 DmgGroups []Group
35265
35266                 //mt:32tou16
35267                 PunchUses int32
35268         }))(obj)); false {
35269                 {
35270                         p := &(*(*(struct {
35271                                 //mt:if _ = %s; false
35272                                 NonNil bool
35273
35274                                 AttackCooldown float32
35275                                 MaxDropLvl     int16
35276
35277                                 //mt:len32
35278                                 GroupCaps []ToolGroupCap
35279
35280                                 //mt:len32
35281                                 DmgGroups []Group
35282
35283                                 //mt:32tou16
35284                                 PunchUses int32
35285                         }))(obj)).NonNil
35286                         switch n := read8(r); n {
35287                         case 0:
35288                                 *p = false
35289                         case 1:
35290                                 *p = true
35291                         default:
35292                                 chk(fmt.Errorf("invalid bool: %d", n))
35293                         }
35294                 }
35295         }
35296         {
35297                 var n uint16
35298                 {
35299                         p := &n
35300                         *p = read16(r)
35301                 }
35302                 r := &io.LimitedReader{R: r, N: int64(n)}
35303                 if r.N > 0 {
35304                         (*(*(struct {
35305                                 //mt:if _ = %s; false
35306                                 NonNil bool
35307
35308                                 AttackCooldown float32
35309                                 MaxDropLvl     int16
35310
35311                                 //mt:len32
35312                                 GroupCaps []ToolGroupCap
35313
35314                                 //mt:len32
35315                                 DmgGroups []Group
35316
35317                                 //mt:32tou16
35318                                 PunchUses int32
35319                         }))(obj)).NonNil = true
35320                 } /**/
35321                 {
35322                         if (*(*(struct {
35323                                 //mt:if _ = %s; false
35324                                 NonNil bool
35325
35326                                 AttackCooldown float32
35327                                 MaxDropLvl     int16
35328
35329                                 //mt:len32
35330                                 GroupCaps []ToolGroupCap
35331
35332                                 //mt:len32
35333                                 DmgGroups []Group
35334
35335                                 //mt:32tou16
35336                                 PunchUses int32
35337                         }))(obj)).NonNil {
35338                                 {
35339                                         var local396 uint8
35340                                         local397 := uint8(5)
35341                                         {
35342                                                 p := &local396
35343                                                 *p = read8(r)
35344                                         }
35345                                         if local396 != local397 {
35346                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local396))
35347                                         }
35348                                 }
35349                                 {
35350                                         p := &(*(*(struct {
35351                                                 //mt:if _ = %s; false
35352                                                 NonNil bool
35353
35354                                                 AttackCooldown float32
35355                                                 MaxDropLvl     int16
35356
35357                                                 //mt:len32
35358                                                 GroupCaps []ToolGroupCap
35359
35360                                                 //mt:len32
35361                                                 DmgGroups []Group
35362
35363                                                 //mt:32tou16
35364                                                 PunchUses int32
35365                                         }))(obj)).AttackCooldown
35366                                         *p = math.Float32frombits(read32(r))
35367                                 }
35368                                 {
35369                                         p := &(*(*(struct {
35370                                                 //mt:if _ = %s; false
35371                                                 NonNil bool
35372
35373                                                 AttackCooldown float32
35374                                                 MaxDropLvl     int16
35375
35376                                                 //mt:len32
35377                                                 GroupCaps []ToolGroupCap
35378
35379                                                 //mt:len32
35380                                                 DmgGroups []Group
35381
35382                                                 //mt:32tou16
35383                                                 PunchUses int32
35384                                         }))(obj)).MaxDropLvl
35385                                         *p = int16(read16(r))
35386                                 }
35387                                 var local398 uint32
35388                                 {
35389                                         p := &local398
35390                                         *p = read32(r)
35391                                 }
35392                                 ((*(*(struct {
35393                                         //mt:if _ = %s; false
35394                                         NonNil bool
35395
35396                                         AttackCooldown float32
35397                                         MaxDropLvl     int16
35398
35399                                         //mt:len32
35400                                         GroupCaps []ToolGroupCap
35401
35402                                         //mt:len32
35403                                         DmgGroups []Group
35404
35405                                         //mt:32tou16
35406                                         PunchUses int32
35407                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local398)
35408                                 for local399 := range (*(*(struct {
35409                                         //mt:if _ = %s; false
35410                                         NonNil bool
35411
35412                                         AttackCooldown float32
35413                                         MaxDropLvl     int16
35414
35415                                         //mt:len32
35416                                         GroupCaps []ToolGroupCap
35417
35418                                         //mt:len32
35419                                         DmgGroups []Group
35420
35421                                         //mt:32tou16
35422                                         PunchUses int32
35423                                 }))(obj)).GroupCaps {
35424                                         if err := pcall(func() {
35425                                                 (((*(*(struct {
35426                                                         //mt:if _ = %s; false
35427                                                         NonNil bool
35428
35429                                                         AttackCooldown float32
35430                                                         MaxDropLvl     int16
35431
35432                                                         //mt:len32
35433                                                         GroupCaps []ToolGroupCap
35434
35435                                                         //mt:len32
35436                                                         DmgGroups []Group
35437
35438                                                         //mt:32tou16
35439                                                         PunchUses int32
35440                                                 }))(obj)).GroupCaps)[local399]).deserialize(r)
35441                                         }); err != nil {
35442                                                 if err == io.EOF {
35443                                                         chk(io.EOF)
35444                                                 }
35445                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
35446                                         }
35447                                 }
35448                                 var local400 uint32
35449                                 {
35450                                         p := &local400
35451                                         *p = read32(r)
35452                                 }
35453                                 ((*(*(struct {
35454                                         //mt:if _ = %s; false
35455                                         NonNil bool
35456
35457                                         AttackCooldown float32
35458                                         MaxDropLvl     int16
35459
35460                                         //mt:len32
35461                                         GroupCaps []ToolGroupCap
35462
35463                                         //mt:len32
35464                                         DmgGroups []Group
35465
35466                                         //mt:32tou16
35467                                         PunchUses int32
35468                                 }))(obj)).DmgGroups) = make([]Group, local400)
35469                                 for local401 := range (*(*(struct {
35470                                         //mt:if _ = %s; false
35471                                         NonNil bool
35472
35473                                         AttackCooldown float32
35474                                         MaxDropLvl     int16
35475
35476                                         //mt:len32
35477                                         GroupCaps []ToolGroupCap
35478
35479                                         //mt:len32
35480                                         DmgGroups []Group
35481
35482                                         //mt:32tou16
35483                                         PunchUses int32
35484                                 }))(obj)).DmgGroups {
35485                                         if err := pcall(func() {
35486                                                 (((*(*(struct {
35487                                                         //mt:if _ = %s; false
35488                                                         NonNil bool
35489
35490                                                         AttackCooldown float32
35491                                                         MaxDropLvl     int16
35492
35493                                                         //mt:len32
35494                                                         GroupCaps []ToolGroupCap
35495
35496                                                         //mt:len32
35497                                                         DmgGroups []Group
35498
35499                                                         //mt:32tou16
35500                                                         PunchUses int32
35501                                                 }))(obj)).DmgGroups)[local401]).deserialize(r)
35502                                         }); err != nil {
35503                                                 if err == io.EOF {
35504                                                         chk(io.EOF)
35505                                                 }
35506                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
35507                                         }
35508                                 }
35509                                 var local402 uint16
35510                                 {
35511                                         p := &local402
35512                                         *p = read16(r)
35513                                 }
35514                                 (*(*(struct {
35515                                         //mt:if _ = %s; false
35516                                         NonNil bool
35517
35518                                         AttackCooldown float32
35519                                         MaxDropLvl     int16
35520
35521                                         //mt:len32
35522                                         GroupCaps []ToolGroupCap
35523
35524                                         //mt:len32
35525                                         DmgGroups []Group
35526
35527                                         //mt:32tou16
35528                                         PunchUses int32
35529                                 }))(obj)).PunchUses = int32(local402)
35530                         }
35531                 }
35532                 if r.N > 0 {
35533                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
35534                 }
35535         }
35536 }
35537
35538 func (obj *AnimType) serialize(w io.Writer) {
35539         {
35540                 x := *(*(uint8))(obj)
35541                 write8(w, uint8(x))
35542         }
35543 }
35544
35545 func (obj *AnimType) deserialize(r io.Reader) {
35546         {
35547                 p := &*(*(uint8))(obj)
35548                 *p = read8(r)
35549         }
35550 }
35551
35552 func (obj *HUDType) serialize(w io.Writer) {
35553         {
35554                 x := *(*(uint8))(obj)
35555                 write8(w, uint8(x))
35556         }
35557 }
35558
35559 func (obj *HUDType) deserialize(r io.Reader) {
35560         {
35561                 p := &*(*(uint8))(obj)
35562                 *p = read8(r)
35563         }
35564 }
35565
35566 func (obj *Box) serialize(w io.Writer) {
35567         for local403 := range *(*([2]Vec))(obj) {
35568                 if err := pcall(func() {
35569                         ((*(*([2]Vec))(obj))[local403]).serialize(w)
35570                 }); err != nil {
35571                         if err == io.EOF {
35572                                 chk(io.EOF)
35573                         }
35574                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
35575                 }
35576         }
35577 }
35578
35579 func (obj *Box) deserialize(r io.Reader) {
35580         for local404 := range *(*([2]Vec))(obj) {
35581                 if err := pcall(func() {
35582                         ((*(*([2]Vec))(obj))[local404]).deserialize(r)
35583                 }); err != nil {
35584                         if err == io.EOF {
35585                                 chk(io.EOF)
35586                         }
35587                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
35588                 }
35589         }
35590 }
35591
35592 func (obj *TileFlags) serialize(w io.Writer) {
35593         {
35594                 x := *(*(uint16))(obj)
35595                 write16(w, uint16(x))
35596         }
35597 }
35598
35599 func (obj *TileFlags) deserialize(r io.Reader) {
35600         {
35601                 p := &*(*(uint16))(obj)
35602                 *p = read16(r)
35603         }
35604 }
35605
35606 func (obj *AlignType) serialize(w io.Writer) {
35607         {
35608                 x := *(*(uint8))(obj)
35609                 write8(w, uint8(x))
35610         }
35611 }
35612
35613 func (obj *AlignType) deserialize(r io.Reader) {
35614         {
35615                 p := &*(*(uint8))(obj)
35616                 *p = read8(r)
35617         }
35618 }
35619
35620 func (obj *NodeBoxType) serialize(w io.Writer) {
35621         {
35622                 x := *(*(uint8))(obj)
35623                 write8(w, uint8(x))
35624         }
35625 }
35626
35627 func (obj *NodeBoxType) deserialize(r io.Reader) {
35628         {
35629                 p := &*(*(uint8))(obj)
35630                 *p = read8(r)
35631         }
35632 }
35633
35634 func (obj *DirBoxes) serialize(w io.Writer) {
35635         if len(((*(*(struct {
35636                 Top, Bot                 []Box
35637                 Front, Left, Back, Right []Box
35638         }))(obj)).Top)) > math.MaxUint16 {
35639                 chk(ErrTooLong)
35640         }
35641         {
35642                 x := uint16(len(((*(*(struct {
35643                         Top, Bot                 []Box
35644                         Front, Left, Back, Right []Box
35645                 }))(obj)).Top)))
35646                 write16(w, uint16(x))
35647         }
35648         for local405 := range (*(*(struct {
35649                 Top, Bot                 []Box
35650                 Front, Left, Back, Right []Box
35651         }))(obj)).Top {
35652                 if err := pcall(func() {
35653                         (((*(*(struct {
35654                                 Top, Bot                 []Box
35655                                 Front, Left, Back, Right []Box
35656                         }))(obj)).Top)[local405]).serialize(w)
35657                 }); err != nil {
35658                         if err == io.EOF {
35659                                 chk(io.EOF)
35660                         }
35661                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35662                 }
35663         }
35664         if len(((*(*(struct {
35665                 Top, Bot                 []Box
35666                 Front, Left, Back, Right []Box
35667         }))(obj)).Bot)) > math.MaxUint16 {
35668                 chk(ErrTooLong)
35669         }
35670         {
35671                 x := uint16(len(((*(*(struct {
35672                         Top, Bot                 []Box
35673                         Front, Left, Back, Right []Box
35674                 }))(obj)).Bot)))
35675                 write16(w, uint16(x))
35676         }
35677         for local406 := range (*(*(struct {
35678                 Top, Bot                 []Box
35679                 Front, Left, Back, Right []Box
35680         }))(obj)).Bot {
35681                 if err := pcall(func() {
35682                         (((*(*(struct {
35683                                 Top, Bot                 []Box
35684                                 Front, Left, Back, Right []Box
35685                         }))(obj)).Bot)[local406]).serialize(w)
35686                 }); err != nil {
35687                         if err == io.EOF {
35688                                 chk(io.EOF)
35689                         }
35690                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35691                 }
35692         }
35693         if len(((*(*(struct {
35694                 Top, Bot                 []Box
35695                 Front, Left, Back, Right []Box
35696         }))(obj)).Front)) > math.MaxUint16 {
35697                 chk(ErrTooLong)
35698         }
35699         {
35700                 x := uint16(len(((*(*(struct {
35701                         Top, Bot                 []Box
35702                         Front, Left, Back, Right []Box
35703                 }))(obj)).Front)))
35704                 write16(w, uint16(x))
35705         }
35706         for local407 := range (*(*(struct {
35707                 Top, Bot                 []Box
35708                 Front, Left, Back, Right []Box
35709         }))(obj)).Front {
35710                 if err := pcall(func() {
35711                         (((*(*(struct {
35712                                 Top, Bot                 []Box
35713                                 Front, Left, Back, Right []Box
35714                         }))(obj)).Front)[local407]).serialize(w)
35715                 }); err != nil {
35716                         if err == io.EOF {
35717                                 chk(io.EOF)
35718                         }
35719                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35720                 }
35721         }
35722         if len(((*(*(struct {
35723                 Top, Bot                 []Box
35724                 Front, Left, Back, Right []Box
35725         }))(obj)).Left)) > math.MaxUint16 {
35726                 chk(ErrTooLong)
35727         }
35728         {
35729                 x := uint16(len(((*(*(struct {
35730                         Top, Bot                 []Box
35731                         Front, Left, Back, Right []Box
35732                 }))(obj)).Left)))
35733                 write16(w, uint16(x))
35734         }
35735         for local408 := range (*(*(struct {
35736                 Top, Bot                 []Box
35737                 Front, Left, Back, Right []Box
35738         }))(obj)).Left {
35739                 if err := pcall(func() {
35740                         (((*(*(struct {
35741                                 Top, Bot                 []Box
35742                                 Front, Left, Back, Right []Box
35743                         }))(obj)).Left)[local408]).serialize(w)
35744                 }); err != nil {
35745                         if err == io.EOF {
35746                                 chk(io.EOF)
35747                         }
35748                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35749                 }
35750         }
35751         if len(((*(*(struct {
35752                 Top, Bot                 []Box
35753                 Front, Left, Back, Right []Box
35754         }))(obj)).Back)) > math.MaxUint16 {
35755                 chk(ErrTooLong)
35756         }
35757         {
35758                 x := uint16(len(((*(*(struct {
35759                         Top, Bot                 []Box
35760                         Front, Left, Back, Right []Box
35761                 }))(obj)).Back)))
35762                 write16(w, uint16(x))
35763         }
35764         for local409 := range (*(*(struct {
35765                 Top, Bot                 []Box
35766                 Front, Left, Back, Right []Box
35767         }))(obj)).Back {
35768                 if err := pcall(func() {
35769                         (((*(*(struct {
35770                                 Top, Bot                 []Box
35771                                 Front, Left, Back, Right []Box
35772                         }))(obj)).Back)[local409]).serialize(w)
35773                 }); err != nil {
35774                         if err == io.EOF {
35775                                 chk(io.EOF)
35776                         }
35777                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35778                 }
35779         }
35780         if len(((*(*(struct {
35781                 Top, Bot                 []Box
35782                 Front, Left, Back, Right []Box
35783         }))(obj)).Right)) > math.MaxUint16 {
35784                 chk(ErrTooLong)
35785         }
35786         {
35787                 x := uint16(len(((*(*(struct {
35788                         Top, Bot                 []Box
35789                         Front, Left, Back, Right []Box
35790                 }))(obj)).Right)))
35791                 write16(w, uint16(x))
35792         }
35793         for local410 := range (*(*(struct {
35794                 Top, Bot                 []Box
35795                 Front, Left, Back, Right []Box
35796         }))(obj)).Right {
35797                 if err := pcall(func() {
35798                         (((*(*(struct {
35799                                 Top, Bot                 []Box
35800                                 Front, Left, Back, Right []Box
35801                         }))(obj)).Right)[local410]).serialize(w)
35802                 }); err != nil {
35803                         if err == io.EOF {
35804                                 chk(io.EOF)
35805                         }
35806                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35807                 }
35808         }
35809 }
35810
35811 func (obj *DirBoxes) deserialize(r io.Reader) {
35812         var local411 uint16
35813         {
35814                 p := &local411
35815                 *p = read16(r)
35816         }
35817         ((*(*(struct {
35818                 Top, Bot                 []Box
35819                 Front, Left, Back, Right []Box
35820         }))(obj)).Top) = make([]Box, local411)
35821         for local412 := range (*(*(struct {
35822                 Top, Bot                 []Box
35823                 Front, Left, Back, Right []Box
35824         }))(obj)).Top {
35825                 if err := pcall(func() {
35826                         (((*(*(struct {
35827                                 Top, Bot                 []Box
35828                                 Front, Left, Back, Right []Box
35829                         }))(obj)).Top)[local412]).deserialize(r)
35830                 }); err != nil {
35831                         if err == io.EOF {
35832                                 chk(io.EOF)
35833                         }
35834                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35835                 }
35836         }
35837         var local413 uint16
35838         {
35839                 p := &local413
35840                 *p = read16(r)
35841         }
35842         ((*(*(struct {
35843                 Top, Bot                 []Box
35844                 Front, Left, Back, Right []Box
35845         }))(obj)).Bot) = make([]Box, local413)
35846         for local414 := range (*(*(struct {
35847                 Top, Bot                 []Box
35848                 Front, Left, Back, Right []Box
35849         }))(obj)).Bot {
35850                 if err := pcall(func() {
35851                         (((*(*(struct {
35852                                 Top, Bot                 []Box
35853                                 Front, Left, Back, Right []Box
35854                         }))(obj)).Bot)[local414]).deserialize(r)
35855                 }); err != nil {
35856                         if err == io.EOF {
35857                                 chk(io.EOF)
35858                         }
35859                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35860                 }
35861         }
35862         var local415 uint16
35863         {
35864                 p := &local415
35865                 *p = read16(r)
35866         }
35867         ((*(*(struct {
35868                 Top, Bot                 []Box
35869                 Front, Left, Back, Right []Box
35870         }))(obj)).Front) = make([]Box, local415)
35871         for local416 := range (*(*(struct {
35872                 Top, Bot                 []Box
35873                 Front, Left, Back, Right []Box
35874         }))(obj)).Front {
35875                 if err := pcall(func() {
35876                         (((*(*(struct {
35877                                 Top, Bot                 []Box
35878                                 Front, Left, Back, Right []Box
35879                         }))(obj)).Front)[local416]).deserialize(r)
35880                 }); err != nil {
35881                         if err == io.EOF {
35882                                 chk(io.EOF)
35883                         }
35884                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35885                 }
35886         }
35887         var local417 uint16
35888         {
35889                 p := &local417
35890                 *p = read16(r)
35891         }
35892         ((*(*(struct {
35893                 Top, Bot                 []Box
35894                 Front, Left, Back, Right []Box
35895         }))(obj)).Left) = make([]Box, local417)
35896         for local418 := range (*(*(struct {
35897                 Top, Bot                 []Box
35898                 Front, Left, Back, Right []Box
35899         }))(obj)).Left {
35900                 if err := pcall(func() {
35901                         (((*(*(struct {
35902                                 Top, Bot                 []Box
35903                                 Front, Left, Back, Right []Box
35904                         }))(obj)).Left)[local418]).deserialize(r)
35905                 }); err != nil {
35906                         if err == io.EOF {
35907                                 chk(io.EOF)
35908                         }
35909                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35910                 }
35911         }
35912         var local419 uint16
35913         {
35914                 p := &local419
35915                 *p = read16(r)
35916         }
35917         ((*(*(struct {
35918                 Top, Bot                 []Box
35919                 Front, Left, Back, Right []Box
35920         }))(obj)).Back) = make([]Box, local419)
35921         for local420 := range (*(*(struct {
35922                 Top, Bot                 []Box
35923                 Front, Left, Back, Right []Box
35924         }))(obj)).Back {
35925                 if err := pcall(func() {
35926                         (((*(*(struct {
35927                                 Top, Bot                 []Box
35928                                 Front, Left, Back, Right []Box
35929                         }))(obj)).Back)[local420]).deserialize(r)
35930                 }); err != nil {
35931                         if err == io.EOF {
35932                                 chk(io.EOF)
35933                         }
35934                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35935                 }
35936         }
35937         var local421 uint16
35938         {
35939                 p := &local421
35940                 *p = read16(r)
35941         }
35942         ((*(*(struct {
35943                 Top, Bot                 []Box
35944                 Front, Left, Back, Right []Box
35945         }))(obj)).Right) = make([]Box, local421)
35946         for local422 := range (*(*(struct {
35947                 Top, Bot                 []Box
35948                 Front, Left, Back, Right []Box
35949         }))(obj)).Right {
35950                 if err := pcall(func() {
35951                         (((*(*(struct {
35952                                 Top, Bot                 []Box
35953                                 Front, Left, Back, Right []Box
35954                         }))(obj)).Right)[local422]).deserialize(r)
35955                 }); err != nil {
35956                         if err == io.EOF {
35957                                 chk(io.EOF)
35958                         }
35959                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35960                 }
35961         }
35962 }
35963
35964 func (obj *ToolGroupCap) serialize(w io.Writer) {
35965         if len(([]byte((*(*(struct {
35966                 Name string
35967
35968                 //mt:32to16
35969                 Uses int32
35970
35971                 MaxLvl int16
35972
35973                 //mt:len32
35974                 Times []DigTime
35975         }))(obj)).Name))) > math.MaxUint16 {
35976                 chk(ErrTooLong)
35977         }
35978         {
35979                 x := uint16(len(([]byte((*(*(struct {
35980                         Name string
35981
35982                         //mt:32to16
35983                         Uses int32
35984
35985                         MaxLvl int16
35986
35987                         //mt:len32
35988                         Times []DigTime
35989                 }))(obj)).Name))))
35990                 write16(w, uint16(x))
35991         }
35992         {
35993                 _, err := w.Write(([]byte((*(*(struct {
35994                         Name string
35995
35996                         //mt:32to16
35997                         Uses int32
35998
35999                         MaxLvl int16
36000
36001                         //mt:len32
36002                         Times []DigTime
36003                 }))(obj)).Name))[:])
36004                 chk(err)
36005         }
36006         {
36007                 x := int16((*(*(struct {
36008                         Name string
36009
36010                         //mt:32to16
36011                         Uses int32
36012
36013                         MaxLvl int16
36014
36015                         //mt:len32
36016                         Times []DigTime
36017                 }))(obj)).Uses)
36018                 write16(w, uint16(x))
36019         }
36020         {
36021                 x := (*(*(struct {
36022                         Name string
36023
36024                         //mt:32to16
36025                         Uses int32
36026
36027                         MaxLvl int16
36028
36029                         //mt:len32
36030                         Times []DigTime
36031                 }))(obj)).MaxLvl
36032                 write16(w, uint16(x))
36033         }
36034         if len(((*(*(struct {
36035                 Name string
36036
36037                 //mt:32to16
36038                 Uses int32
36039
36040                 MaxLvl int16
36041
36042                 //mt:len32
36043                 Times []DigTime
36044         }))(obj)).Times)) > math.MaxUint32 {
36045                 chk(ErrTooLong)
36046         }
36047         {
36048                 x := uint32(len(((*(*(struct {
36049                         Name string
36050
36051                         //mt:32to16
36052                         Uses int32
36053
36054                         MaxLvl int16
36055
36056                         //mt:len32
36057                         Times []DigTime
36058                 }))(obj)).Times)))
36059                 write32(w, uint32(x))
36060         }
36061         for local423 := range (*(*(struct {
36062                 Name string
36063
36064                 //mt:32to16
36065                 Uses int32
36066
36067                 MaxLvl int16
36068
36069                 //mt:len32
36070                 Times []DigTime
36071         }))(obj)).Times {
36072                 if err := pcall(func() {
36073                         (((*(*(struct {
36074                                 Name string
36075
36076                                 //mt:32to16
36077                                 Uses int32
36078
36079                                 MaxLvl int16
36080
36081                                 //mt:len32
36082                                 Times []DigTime
36083                         }))(obj)).Times)[local423]).serialize(w)
36084                 }); err != nil {
36085                         if err == io.EOF {
36086                                 chk(io.EOF)
36087                         }
36088                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
36089                 }
36090         }
36091 }
36092
36093 func (obj *ToolGroupCap) deserialize(r io.Reader) {
36094         var local424 []uint8
36095         var local425 uint16
36096         {
36097                 p := &local425
36098                 *p = read16(r)
36099         }
36100         (local424) = make([]uint8, local425)
36101         {
36102                 _, err := io.ReadFull(r, (local424)[:])
36103                 chk(err)
36104         }
36105         ((*(*(struct {
36106                 Name string
36107
36108                 //mt:32to16
36109                 Uses int32
36110
36111                 MaxLvl int16
36112
36113                 //mt:len32
36114                 Times []DigTime
36115         }))(obj)).Name) = string(local424)
36116         var local426 int16
36117         {
36118                 p := &local426
36119                 *p = int16(read16(r))
36120         }
36121         (*(*(struct {
36122                 Name string
36123
36124                 //mt:32to16
36125                 Uses int32
36126
36127                 MaxLvl int16
36128
36129                 //mt:len32
36130                 Times []DigTime
36131         }))(obj)).Uses = int32(local426)
36132         {
36133                 p := &(*(*(struct {
36134                         Name string
36135
36136                         //mt:32to16
36137                         Uses int32
36138
36139                         MaxLvl int16
36140
36141                         //mt:len32
36142                         Times []DigTime
36143                 }))(obj)).MaxLvl
36144                 *p = int16(read16(r))
36145         }
36146         var local427 uint32
36147         {
36148                 p := &local427
36149                 *p = read32(r)
36150         }
36151         ((*(*(struct {
36152                 Name string
36153
36154                 //mt:32to16
36155                 Uses int32
36156
36157                 MaxLvl int16
36158
36159                 //mt:len32
36160                 Times []DigTime
36161         }))(obj)).Times) = make([]DigTime, local427)
36162         for local428 := range (*(*(struct {
36163                 Name string
36164
36165                 //mt:32to16
36166                 Uses int32
36167
36168                 MaxLvl int16
36169
36170                 //mt:len32
36171                 Times []DigTime
36172         }))(obj)).Times {
36173                 if err := pcall(func() {
36174                         (((*(*(struct {
36175                                 Name string
36176
36177                                 //mt:32to16
36178                                 Uses int32
36179
36180                                 MaxLvl int16
36181
36182                                 //mt:len32
36183                                 Times []DigTime
36184                         }))(obj)).Times)[local428]).deserialize(r)
36185                 }); err != nil {
36186                         if err == io.EOF {
36187                                 chk(io.EOF)
36188                         }
36189                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
36190                 }
36191         }
36192 }
36193
36194 func (obj *DigTime) serialize(w io.Writer) {
36195         {
36196                 x := (*(*(struct {
36197                         Rating int16
36198                         Time   float32
36199                 }))(obj)).Rating
36200                 write16(w, uint16(x))
36201         }
36202         {
36203                 x := (*(*(struct {
36204                         Rating int16
36205                         Time   float32
36206                 }))(obj)).Time
36207                 write32(w, math.Float32bits(x))
36208         }
36209 }
36210
36211 func (obj *DigTime) deserialize(r io.Reader) {
36212         {
36213                 p := &(*(*(struct {
36214                         Rating int16
36215                         Time   float32
36216                 }))(obj)).Rating
36217                 *p = int16(read16(r))
36218         }
36219         {
36220                 p := &(*(*(struct {
36221                         Rating int16
36222                         Time   float32
36223                 }))(obj)).Time
36224                 *p = math.Float32frombits(read32(r))
36225         }
36226 }