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                         //mt:opt
2865                         DamageEffect bool
2866                 }))(obj)).HP
2867                 write16(w, uint16(x))
2868         }
2869         if err := pcall(func() {
2870                 {
2871                         x := (*(*(struct {
2872                                 HP uint16
2873                                 //mt:opt
2874                                 DamageEffect bool
2875                         }))(obj)).DamageEffect
2876                         if x {
2877                                 write8(w, 1)
2878                         } else {
2879                                 write8(w, 0)
2880                         }
2881                 }
2882         }); err != nil && err != io.EOF {
2883                 chk(err)
2884         }
2885 }
2886
2887 func (obj *ToCltHP) Deserialize(r io.Reader) {
2888         {
2889                 p := &(*(*(struct {
2890                         HP uint16
2891                         //mt:opt
2892                         DamageEffect bool
2893                 }))(obj)).HP
2894                 *p = read16(r)
2895         }
2896         if err := pcall(func() {
2897                 {
2898                         p := &(*(*(struct {
2899                                 HP uint16
2900                                 //mt:opt
2901                                 DamageEffect bool
2902                         }))(obj)).DamageEffect
2903                         switch n := read8(r); n {
2904                         case 0:
2905                                 *p = false
2906                         case 1:
2907                                 *p = true
2908                         default:
2909                                 chk(fmt.Errorf("invalid bool: %d", n))
2910                         }
2911                 }
2912         }); err != nil && err != io.EOF {
2913                 chk(err)
2914         }
2915 }
2916
2917 func (obj *ToCltMovePlayer) Serialize(w io.Writer) {
2918         if err := pcall(func() {
2919                 ((*(*(struct {
2920                         Pos
2921                         Pitch, Yaw float32
2922                 }))(obj)).Pos).Serialize(w)
2923         }); err != nil {
2924                 if err == io.EOF {
2925                         chk(io.EOF)
2926                 }
2927                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
2928         }
2929         {
2930                 x := (*(*(struct {
2931                         Pos
2932                         Pitch, Yaw float32
2933                 }))(obj)).Pitch
2934                 write32(w, math.Float32bits(x))
2935         }
2936         {
2937                 x := (*(*(struct {
2938                         Pos
2939                         Pitch, Yaw float32
2940                 }))(obj)).Yaw
2941                 write32(w, math.Float32bits(x))
2942         }
2943 }
2944
2945 func (obj *ToCltMovePlayer) Deserialize(r io.Reader) {
2946         if err := pcall(func() {
2947                 ((*(*(struct {
2948                         Pos
2949                         Pitch, Yaw float32
2950                 }))(obj)).Pos).Deserialize(r)
2951         }); err != nil {
2952                 if err == io.EOF {
2953                         chk(io.EOF)
2954                 }
2955                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
2956         }
2957         {
2958                 p := &(*(*(struct {
2959                         Pos
2960                         Pitch, Yaw float32
2961                 }))(obj)).Pitch
2962                 *p = math.Float32frombits(read32(r))
2963         }
2964         {
2965                 p := &(*(*(struct {
2966                         Pos
2967                         Pitch, Yaw float32
2968                 }))(obj)).Yaw
2969                 *p = math.Float32frombits(read32(r))
2970         }
2971 }
2972
2973 func (obj *ToCltLegacyKick) Serialize(w io.Writer) {
2974         local94 := utf16.Encode([]rune((*(*(struct {
2975                 //mt:utf16
2976                 Reason string
2977         }))(obj)).Reason))
2978         if len((local94)) > math.MaxUint16 {
2979                 chk(ErrTooLong)
2980         }
2981         {
2982                 x := uint16(len((local94)))
2983                 write16(w, uint16(x))
2984         }
2985         for local95 := range local94 {
2986                 {
2987                         x := (local94)[local95]
2988                         write16(w, uint16(x))
2989                 }
2990         }
2991 }
2992
2993 func (obj *ToCltLegacyKick) Deserialize(r io.Reader) {
2994         var local96 []uint16
2995         var local97 uint16
2996         {
2997                 p := &local97
2998                 *p = read16(r)
2999         }
3000         (local96) = make([]uint16, local97)
3001         for local98 := range local96 {
3002                 {
3003                         p := &(local96)[local98]
3004                         *p = read16(r)
3005                 }
3006         }
3007         (*(*(struct {
3008                 //mt:utf16
3009                 Reason string
3010         }))(obj)).Reason = string(utf16.Decode(local96))
3011 }
3012
3013 func (obj *ToCltFOV) Serialize(w io.Writer) {
3014         {
3015                 x := (*(*(struct {
3016                         FOV            float32
3017                         Multiplier     bool
3018                         TransitionTime float32
3019                 }))(obj)).FOV
3020                 write32(w, math.Float32bits(x))
3021         }
3022         {
3023                 x := (*(*(struct {
3024                         FOV            float32
3025                         Multiplier     bool
3026                         TransitionTime float32
3027                 }))(obj)).Multiplier
3028                 if x {
3029                         write8(w, 1)
3030                 } else {
3031                         write8(w, 0)
3032                 }
3033         }
3034         {
3035                 x := (*(*(struct {
3036                         FOV            float32
3037                         Multiplier     bool
3038                         TransitionTime float32
3039                 }))(obj)).TransitionTime
3040                 write32(w, math.Float32bits(x))
3041         }
3042 }
3043
3044 func (obj *ToCltFOV) Deserialize(r io.Reader) {
3045         {
3046                 p := &(*(*(struct {
3047                         FOV            float32
3048                         Multiplier     bool
3049                         TransitionTime float32
3050                 }))(obj)).FOV
3051                 *p = math.Float32frombits(read32(r))
3052         }
3053         {
3054                 p := &(*(*(struct {
3055                         FOV            float32
3056                         Multiplier     bool
3057                         TransitionTime float32
3058                 }))(obj)).Multiplier
3059                 switch n := read8(r); n {
3060                 case 0:
3061                         *p = false
3062                 case 1:
3063                         *p = true
3064                 default:
3065                         chk(fmt.Errorf("invalid bool: %d", n))
3066                 }
3067         }
3068         {
3069                 p := &(*(*(struct {
3070                         FOV            float32
3071                         Multiplier     bool
3072                         TransitionTime float32
3073                 }))(obj)).TransitionTime
3074                 *p = math.Float32frombits(read32(r))
3075         }
3076 }
3077
3078 func (obj *ToCltDeathScreen) Serialize(w io.Writer) {
3079         {
3080                 x := (*(*(struct {
3081                         PointCam bool
3082                         PointAt  Pos
3083                 }))(obj)).PointCam
3084                 if x {
3085                         write8(w, 1)
3086                 } else {
3087                         write8(w, 0)
3088                 }
3089         }
3090         if err := pcall(func() {
3091                 ((*(*(struct {
3092                         PointCam bool
3093                         PointAt  Pos
3094                 }))(obj)).PointAt).Serialize(w)
3095         }); err != nil {
3096                 if err == io.EOF {
3097                         chk(io.EOF)
3098                 }
3099                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
3100         }
3101 }
3102
3103 func (obj *ToCltDeathScreen) Deserialize(r io.Reader) {
3104         {
3105                 p := &(*(*(struct {
3106                         PointCam bool
3107                         PointAt  Pos
3108                 }))(obj)).PointCam
3109                 switch n := read8(r); n {
3110                 case 0:
3111                         *p = false
3112                 case 1:
3113                         *p = true
3114                 default:
3115                         chk(fmt.Errorf("invalid bool: %d", n))
3116                 }
3117         }
3118         if err := pcall(func() {
3119                 ((*(*(struct {
3120                         PointCam bool
3121                         PointAt  Pos
3122                 }))(obj)).PointAt).Deserialize(r)
3123         }); err != nil {
3124                 if err == io.EOF {
3125                         chk(io.EOF)
3126                 }
3127                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
3128         }
3129 }
3130
3131 func (obj *ToCltMedia) Serialize(w io.Writer) {
3132         {
3133                 x := (*(*(struct {
3134                         // N is the total number of ToCltMedia packets.
3135                         // I is the index of this packet.
3136                         N, I uint16
3137
3138                         //mt:len32
3139                         Files []struct {
3140                                 Name string
3141
3142                                 //mt:len32
3143                                 Data []byte
3144                         }
3145                 }))(obj)).N
3146                 write16(w, uint16(x))
3147         }
3148         {
3149                 x := (*(*(struct {
3150                         // N is the total number of ToCltMedia packets.
3151                         // I is the index of this packet.
3152                         N, I uint16
3153
3154                         //mt:len32
3155                         Files []struct {
3156                                 Name string
3157
3158                                 //mt:len32
3159                                 Data []byte
3160                         }
3161                 }))(obj)).I
3162                 write16(w, uint16(x))
3163         }
3164         if len(((*(*(struct {
3165                 // N is the total number of ToCltMedia packets.
3166                 // I is the index of this packet.
3167                 N, I uint16
3168
3169                 //mt:len32
3170                 Files []struct {
3171                         Name string
3172
3173                         //mt:len32
3174                         Data []byte
3175                 }
3176         }))(obj)).Files)) > math.MaxUint32 {
3177                 chk(ErrTooLong)
3178         }
3179         {
3180                 x := uint32(len(((*(*(struct {
3181                         // N is the total number of ToCltMedia packets.
3182                         // I is the index of this packet.
3183                         N, I uint16
3184
3185                         //mt:len32
3186                         Files []struct {
3187                                 Name string
3188
3189                                 //mt:len32
3190                                 Data []byte
3191                         }
3192                 }))(obj)).Files)))
3193                 write32(w, uint32(x))
3194         }
3195         for local99 := range (*(*(struct {
3196                 // N is the total number of ToCltMedia packets.
3197                 // I is the index of this packet.
3198                 N, I uint16
3199
3200                 //mt:len32
3201                 Files []struct {
3202                         Name string
3203
3204                         //mt:len32
3205                         Data []byte
3206                 }
3207         }))(obj)).Files {
3208                 if len(([]byte((((*(*(struct {
3209                         // N is the total number of ToCltMedia packets.
3210                         // I is the index of this packet.
3211                         N, I uint16
3212
3213                         //mt:len32
3214                         Files []struct {
3215                                 Name string
3216
3217                                 //mt:len32
3218                                 Data []byte
3219                         }
3220                 }))(obj)).Files)[local99]).Name))) > math.MaxUint16 {
3221                         chk(ErrTooLong)
3222                 }
3223                 {
3224                         x := uint16(len(([]byte((((*(*(struct {
3225                                 // N is the total number of ToCltMedia packets.
3226                                 // I is the index of this packet.
3227                                 N, I uint16
3228
3229                                 //mt:len32
3230                                 Files []struct {
3231                                         Name string
3232
3233                                         //mt:len32
3234                                         Data []byte
3235                                 }
3236                         }))(obj)).Files)[local99]).Name))))
3237                         write16(w, uint16(x))
3238                 }
3239                 {
3240                         _, err := w.Write(([]byte((((*(*(struct {
3241                                 // N is the total number of ToCltMedia packets.
3242                                 // I is the index of this packet.
3243                                 N, I uint16
3244
3245                                 //mt:len32
3246                                 Files []struct {
3247                                         Name string
3248
3249                                         //mt:len32
3250                                         Data []byte
3251                                 }
3252                         }))(obj)).Files)[local99]).Name))[:])
3253                         chk(err)
3254                 }
3255                 if len(((((*(*(struct {
3256                         // N is the total number of ToCltMedia packets.
3257                         // I is the index of this packet.
3258                         N, I uint16
3259
3260                         //mt:len32
3261                         Files []struct {
3262                                 Name string
3263
3264                                 //mt:len32
3265                                 Data []byte
3266                         }
3267                 }))(obj)).Files)[local99]).Data)) > math.MaxUint32 {
3268                         chk(ErrTooLong)
3269                 }
3270                 {
3271                         x := uint32(len(((((*(*(struct {
3272                                 // N is the total number of ToCltMedia packets.
3273                                 // I is the index of this packet.
3274                                 N, I uint16
3275
3276                                 //mt:len32
3277                                 Files []struct {
3278                                         Name string
3279
3280                                         //mt:len32
3281                                         Data []byte
3282                                 }
3283                         }))(obj)).Files)[local99]).Data)))
3284                         write32(w, uint32(x))
3285                 }
3286                 {
3287                         _, err := w.Write(((((*(*(struct {
3288                                 // N is the total number of ToCltMedia packets.
3289                                 // I is the index of this packet.
3290                                 N, I uint16
3291
3292                                 //mt:len32
3293                                 Files []struct {
3294                                         Name string
3295
3296                                         //mt:len32
3297                                         Data []byte
3298                                 }
3299                         }))(obj)).Files)[local99]).Data)[:])
3300                         chk(err)
3301                 }
3302         }
3303 }
3304
3305 func (obj *ToCltMedia) Deserialize(r io.Reader) {
3306         {
3307                 p := &(*(*(struct {
3308                         // N is the total number of ToCltMedia packets.
3309                         // I is the index of this packet.
3310                         N, I uint16
3311
3312                         //mt:len32
3313                         Files []struct {
3314                                 Name string
3315
3316                                 //mt:len32
3317                                 Data []byte
3318                         }
3319                 }))(obj)).N
3320                 *p = read16(r)
3321         }
3322         {
3323                 p := &(*(*(struct {
3324                         // N is the total number of ToCltMedia packets.
3325                         // I is the index of this packet.
3326                         N, I uint16
3327
3328                         //mt:len32
3329                         Files []struct {
3330                                 Name string
3331
3332                                 //mt:len32
3333                                 Data []byte
3334                         }
3335                 }))(obj)).I
3336                 *p = read16(r)
3337         }
3338         var local100 uint32
3339         {
3340                 p := &local100
3341                 *p = read32(r)
3342         }
3343         ((*(*(struct {
3344                 // N is the total number of ToCltMedia packets.
3345                 // I is the index of this packet.
3346                 N, I uint16
3347
3348                 //mt:len32
3349                 Files []struct {
3350                         Name string
3351
3352                         //mt:len32
3353                         Data []byte
3354                 }
3355         }))(obj)).Files) = make([]struct {
3356                 Name string
3357                 Data []byte
3358         }, local100)
3359         for local101 := range (*(*(struct {
3360                 // N is the total number of ToCltMedia packets.
3361                 // I is the index of this packet.
3362                 N, I uint16
3363
3364                 //mt:len32
3365                 Files []struct {
3366                         Name string
3367
3368                         //mt:len32
3369                         Data []byte
3370                 }
3371         }))(obj)).Files {
3372                 var local102 []uint8
3373                 var local103 uint16
3374                 {
3375                         p := &local103
3376                         *p = read16(r)
3377                 }
3378                 (local102) = make([]uint8, local103)
3379                 {
3380                         _, err := io.ReadFull(r, (local102)[:])
3381                         chk(err)
3382                 }
3383                 ((((*(*(struct {
3384                         // N is the total number of ToCltMedia packets.
3385                         // I is the index of this packet.
3386                         N, I uint16
3387
3388                         //mt:len32
3389                         Files []struct {
3390                                 Name string
3391
3392                                 //mt:len32
3393                                 Data []byte
3394                         }
3395                 }))(obj)).Files)[local101]).Name) = string(local102)
3396                 var local104 uint32
3397                 {
3398                         p := &local104
3399                         *p = read32(r)
3400                 }
3401                 ((((*(*(struct {
3402                         // N is the total number of ToCltMedia packets.
3403                         // I is the index of this packet.
3404                         N, I uint16
3405
3406                         //mt:len32
3407                         Files []struct {
3408                                 Name string
3409
3410                                 //mt:len32
3411                                 Data []byte
3412                         }
3413                 }))(obj)).Files)[local101]).Data) = make([]byte, local104)
3414                 {
3415                         _, err := io.ReadFull(r, ((((*(*(struct {
3416                                 // N is the total number of ToCltMedia packets.
3417                                 // I is the index of this packet.
3418                                 N, I uint16
3419
3420                                 //mt:len32
3421                                 Files []struct {
3422                                         Name string
3423
3424                                         //mt:len32
3425                                         Data []byte
3426                                 }
3427                         }))(obj)).Files)[local101]).Data)[:])
3428                         chk(err)
3429                 }
3430         }
3431 }
3432
3433 func (obj *ToCltNodeDefs) Serialize(w io.Writer) {
3434         {
3435                 ow := w
3436                 w := new(bytes.Buffer)
3437                 {
3438                         w := zlib.NewWriter(w)
3439                         {
3440                                 local105 := uint8(1)
3441                                 {
3442                                         x := local105
3443                                         write8(w, uint8(x))
3444                                 }
3445                         }
3446                         {
3447                                 x := (*(*(struct {
3448
3449                                         // See (de)serialize.fmt.
3450                                         Defs []NodeDef
3451                                 }))(obj)).Defs
3452                                 { // For ToCltNodeDefs.Defs.
3453                                         if len(x) > math.MaxUint16 {
3454                                                 chk(ErrTooLong)
3455                                         }
3456                                         write16(w, uint16(len(x)))
3457                                         var b bytes.Buffer
3458                                         for i := range x {
3459                                                 x[i].Serialize(&b)
3460                                         }
3461                                         if b.Len() > math.MaxUint32 {
3462                                                 chk(ErrTooLong)
3463                                         }
3464                                         write32(w, uint32(b.Len()))
3465                                         _, err := b.WriteTo(w)
3466                                         chk(err)
3467                                 }
3468                         }
3469                         chk(w.Close())
3470                 }
3471                 {
3472                         buf := w
3473                         w := ow
3474                         if len((buf.Bytes())) > math.MaxUint32 {
3475                                 chk(ErrTooLong)
3476                         }
3477                         {
3478                                 x := uint32(len((buf.Bytes())))
3479                                 write32(w, uint32(x))
3480                         }
3481                         {
3482                                 _, err := w.Write((buf.Bytes())[:])
3483                                 chk(err)
3484                         }
3485                 }
3486         }
3487 }
3488
3489 func (obj *ToCltNodeDefs) Deserialize(r io.Reader) {
3490         {
3491                 var n uint32
3492                 {
3493                         p := &n
3494                         *p = read32(r)
3495                 }
3496                 r := &io.LimitedReader{R: r, N: int64(n)}
3497                 {
3498                         r, err := zlib.NewReader(byteReader{r})
3499                         chk(err)
3500                         {
3501                                 var local106 uint8
3502                                 local107 := uint8(1)
3503                                 {
3504                                         p := &local106
3505                                         *p = read8(r)
3506                                 }
3507                                 if local106 != local107 {
3508                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local106))
3509                                 }
3510                         }
3511                         {
3512                                 p := &(*(*(struct {
3513
3514                                         // See (de)serialize.fmt.
3515                                         Defs []NodeDef
3516                                 }))(obj)).Defs
3517                                 { // For ToCltNodeDefs.Defs.
3518                                         *p = make([]NodeDef, read16(r))
3519                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3520                                         for i := range *p {
3521                                                 (*p)[i].Deserialize(r)
3522                                         }
3523                                         if r.N > 0 {
3524                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3525                                         }
3526                                 }
3527                         }
3528                         chk(r.Close())
3529                 }
3530                 if r.N > 0 {
3531                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3532                 }
3533         }
3534 }
3535
3536 func (obj *ToCltAnnounceMedia) Serialize(w io.Writer) {
3537         if len(((*(*(struct {
3538                 Files []struct {
3539                         Name       string
3540                         Base64SHA1 string
3541                 }
3542                 URL string
3543         }))(obj)).Files)) > math.MaxUint16 {
3544                 chk(ErrTooLong)
3545         }
3546         {
3547                 x := uint16(len(((*(*(struct {
3548                         Files []struct {
3549                                 Name       string
3550                                 Base64SHA1 string
3551                         }
3552                         URL string
3553                 }))(obj)).Files)))
3554                 write16(w, uint16(x))
3555         }
3556         for local108 := range (*(*(struct {
3557                 Files []struct {
3558                         Name       string
3559                         Base64SHA1 string
3560                 }
3561                 URL string
3562         }))(obj)).Files {
3563                 if len(([]byte((((*(*(struct {
3564                         Files []struct {
3565                                 Name       string
3566                                 Base64SHA1 string
3567                         }
3568                         URL string
3569                 }))(obj)).Files)[local108]).Name))) > math.MaxUint16 {
3570                         chk(ErrTooLong)
3571                 }
3572                 {
3573                         x := uint16(len(([]byte((((*(*(struct {
3574                                 Files []struct {
3575                                         Name       string
3576                                         Base64SHA1 string
3577                                 }
3578                                 URL string
3579                         }))(obj)).Files)[local108]).Name))))
3580                         write16(w, uint16(x))
3581                 }
3582                 {
3583                         _, err := w.Write(([]byte((((*(*(struct {
3584                                 Files []struct {
3585                                         Name       string
3586                                         Base64SHA1 string
3587                                 }
3588                                 URL string
3589                         }))(obj)).Files)[local108]).Name))[:])
3590                         chk(err)
3591                 }
3592                 if len(([]byte((((*(*(struct {
3593                         Files []struct {
3594                                 Name       string
3595                                 Base64SHA1 string
3596                         }
3597                         URL string
3598                 }))(obj)).Files)[local108]).Base64SHA1))) > math.MaxUint16 {
3599                         chk(ErrTooLong)
3600                 }
3601                 {
3602                         x := uint16(len(([]byte((((*(*(struct {
3603                                 Files []struct {
3604                                         Name       string
3605                                         Base64SHA1 string
3606                                 }
3607                                 URL string
3608                         }))(obj)).Files)[local108]).Base64SHA1))))
3609                         write16(w, uint16(x))
3610                 }
3611                 {
3612                         _, err := w.Write(([]byte((((*(*(struct {
3613                                 Files []struct {
3614                                         Name       string
3615                                         Base64SHA1 string
3616                                 }
3617                                 URL string
3618                         }))(obj)).Files)[local108]).Base64SHA1))[:])
3619                         chk(err)
3620                 }
3621         }
3622         if len(([]byte((*(*(struct {
3623                 Files []struct {
3624                         Name       string
3625                         Base64SHA1 string
3626                 }
3627                 URL string
3628         }))(obj)).URL))) > math.MaxUint16 {
3629                 chk(ErrTooLong)
3630         }
3631         {
3632                 x := uint16(len(([]byte((*(*(struct {
3633                         Files []struct {
3634                                 Name       string
3635                                 Base64SHA1 string
3636                         }
3637                         URL string
3638                 }))(obj)).URL))))
3639                 write16(w, uint16(x))
3640         }
3641         {
3642                 _, err := w.Write(([]byte((*(*(struct {
3643                         Files []struct {
3644                                 Name       string
3645                                 Base64SHA1 string
3646                         }
3647                         URL string
3648                 }))(obj)).URL))[:])
3649                 chk(err)
3650         }
3651 }
3652
3653 func (obj *ToCltAnnounceMedia) Deserialize(r io.Reader) {
3654         var local109 uint16
3655         {
3656                 p := &local109
3657                 *p = read16(r)
3658         }
3659         ((*(*(struct {
3660                 Files []struct {
3661                         Name       string
3662                         Base64SHA1 string
3663                 }
3664                 URL string
3665         }))(obj)).Files) = make([]struct {
3666                 Name       string
3667                 Base64SHA1 string
3668         }, local109)
3669         for local110 := range (*(*(struct {
3670                 Files []struct {
3671                         Name       string
3672                         Base64SHA1 string
3673                 }
3674                 URL string
3675         }))(obj)).Files {
3676                 var local111 []uint8
3677                 var local112 uint16
3678                 {
3679                         p := &local112
3680                         *p = read16(r)
3681                 }
3682                 (local111) = make([]uint8, local112)
3683                 {
3684                         _, err := io.ReadFull(r, (local111)[:])
3685                         chk(err)
3686                 }
3687                 ((((*(*(struct {
3688                         Files []struct {
3689                                 Name       string
3690                                 Base64SHA1 string
3691                         }
3692                         URL string
3693                 }))(obj)).Files)[local110]).Name) = string(local111)
3694                 var local113 []uint8
3695                 var local114 uint16
3696                 {
3697                         p := &local114
3698                         *p = read16(r)
3699                 }
3700                 (local113) = make([]uint8, local114)
3701                 {
3702                         _, err := io.ReadFull(r, (local113)[:])
3703                         chk(err)
3704                 }
3705                 ((((*(*(struct {
3706                         Files []struct {
3707                                 Name       string
3708                                 Base64SHA1 string
3709                         }
3710                         URL string
3711                 }))(obj)).Files)[local110]).Base64SHA1) = string(local113)
3712         }
3713         var local115 []uint8
3714         var local116 uint16
3715         {
3716                 p := &local116
3717                 *p = read16(r)
3718         }
3719         (local115) = make([]uint8, local116)
3720         {
3721                 _, err := io.ReadFull(r, (local115)[:])
3722                 chk(err)
3723         }
3724         ((*(*(struct {
3725                 Files []struct {
3726                         Name       string
3727                         Base64SHA1 string
3728                 }
3729                 URL string
3730         }))(obj)).URL) = string(local115)
3731 }
3732
3733 func (obj *ToCltItemDefs) Serialize(w io.Writer) {
3734         {
3735                 ow := w
3736                 w := new(bytes.Buffer)
3737                 {
3738                         w := zlib.NewWriter(w)
3739                         {
3740                                 local117 := uint8(0)
3741                                 {
3742                                         x := local117
3743                                         write8(w, uint8(x))
3744                                 }
3745                         }
3746                         if len(((*(*(struct {
3747                                 Defs    []ItemDef
3748                                 Aliases []struct{ Alias, Orig string }
3749                         }))(obj)).Defs)) > math.MaxUint16 {
3750                                 chk(ErrTooLong)
3751                         }
3752                         {
3753                                 x := uint16(len(((*(*(struct {
3754                                         Defs    []ItemDef
3755                                         Aliases []struct{ Alias, Orig string }
3756                                 }))(obj)).Defs)))
3757                                 write16(w, uint16(x))
3758                         }
3759                         for local118 := range (*(*(struct {
3760                                 Defs    []ItemDef
3761                                 Aliases []struct{ Alias, Orig string }
3762                         }))(obj)).Defs {
3763                                 if err := pcall(func() {
3764                                         (((*(*(struct {
3765                                                 Defs    []ItemDef
3766                                                 Aliases []struct{ Alias, Orig string }
3767                                         }))(obj)).Defs)[local118]).Serialize(w)
3768                                 }); err != nil {
3769                                         if err == io.EOF {
3770                                                 chk(io.EOF)
3771                                         }
3772                                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemDef", err))
3773                                 }
3774                         }
3775                         if len(((*(*(struct {
3776                                 Defs    []ItemDef
3777                                 Aliases []struct{ Alias, Orig string }
3778                         }))(obj)).Aliases)) > math.MaxUint16 {
3779                                 chk(ErrTooLong)
3780                         }
3781                         {
3782                                 x := uint16(len(((*(*(struct {
3783                                         Defs    []ItemDef
3784                                         Aliases []struct{ Alias, Orig string }
3785                                 }))(obj)).Aliases)))
3786                                 write16(w, uint16(x))
3787                         }
3788                         for local119 := range (*(*(struct {
3789                                 Defs    []ItemDef
3790                                 Aliases []struct{ Alias, Orig string }
3791                         }))(obj)).Aliases {
3792                                 if len(([]byte((((*(*(struct {
3793                                         Defs    []ItemDef
3794                                         Aliases []struct{ Alias, Orig string }
3795                                 }))(obj)).Aliases)[local119]).Alias))) > math.MaxUint16 {
3796                                         chk(ErrTooLong)
3797                                 }
3798                                 {
3799                                         x := uint16(len(([]byte((((*(*(struct {
3800                                                 Defs    []ItemDef
3801                                                 Aliases []struct{ Alias, Orig string }
3802                                         }))(obj)).Aliases)[local119]).Alias))))
3803                                         write16(w, uint16(x))
3804                                 }
3805                                 {
3806                                         _, err := w.Write(([]byte((((*(*(struct {
3807                                                 Defs    []ItemDef
3808                                                 Aliases []struct{ Alias, Orig string }
3809                                         }))(obj)).Aliases)[local119]).Alias))[:])
3810                                         chk(err)
3811                                 }
3812                                 if len(([]byte((((*(*(struct {
3813                                         Defs    []ItemDef
3814                                         Aliases []struct{ Alias, Orig string }
3815                                 }))(obj)).Aliases)[local119]).Orig))) > math.MaxUint16 {
3816                                         chk(ErrTooLong)
3817                                 }
3818                                 {
3819                                         x := uint16(len(([]byte((((*(*(struct {
3820                                                 Defs    []ItemDef
3821                                                 Aliases []struct{ Alias, Orig string }
3822                                         }))(obj)).Aliases)[local119]).Orig))))
3823                                         write16(w, uint16(x))
3824                                 }
3825                                 {
3826                                         _, err := w.Write(([]byte((((*(*(struct {
3827                                                 Defs    []ItemDef
3828                                                 Aliases []struct{ Alias, Orig string }
3829                                         }))(obj)).Aliases)[local119]).Orig))[:])
3830                                         chk(err)
3831                                 }
3832                         }
3833                         chk(w.Close())
3834                 }
3835                 {
3836                         buf := w
3837                         w := ow
3838                         if len((buf.Bytes())) > math.MaxUint32 {
3839                                 chk(ErrTooLong)
3840                         }
3841                         {
3842                                 x := uint32(len((buf.Bytes())))
3843                                 write32(w, uint32(x))
3844                         }
3845                         {
3846                                 _, err := w.Write((buf.Bytes())[:])
3847                                 chk(err)
3848                         }
3849                 }
3850         }
3851 }
3852
3853 func (obj *ToCltItemDefs) Deserialize(r io.Reader) {
3854         {
3855                 var n uint32
3856                 {
3857                         p := &n
3858                         *p = read32(r)
3859                 }
3860                 r := &io.LimitedReader{R: r, N: int64(n)}
3861                 {
3862                         r, err := zlib.NewReader(byteReader{r})
3863                         chk(err)
3864                         {
3865                                 var local120 uint8
3866                                 local121 := uint8(0)
3867                                 {
3868                                         p := &local120
3869                                         *p = read8(r)
3870                                 }
3871                                 if local120 != local121 {
3872                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local120))
3873                                 }
3874                         }
3875                         var local122 uint16
3876                         {
3877                                 p := &local122
3878                                 *p = read16(r)
3879                         }
3880                         ((*(*(struct {
3881                                 Defs    []ItemDef
3882                                 Aliases []struct{ Alias, Orig string }
3883                         }))(obj)).Defs) = make([]ItemDef, local122)
3884                         for local123 := range (*(*(struct {
3885                                 Defs    []ItemDef
3886                                 Aliases []struct{ Alias, Orig string }
3887                         }))(obj)).Defs {
3888                                 if err := pcall(func() {
3889                                         (((*(*(struct {
3890                                                 Defs    []ItemDef
3891                                                 Aliases []struct{ Alias, Orig string }
3892                                         }))(obj)).Defs)[local123]).Deserialize(r)
3893                                 }); err != nil {
3894                                         if err == io.EOF {
3895                                                 chk(io.EOF)
3896                                         }
3897                                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemDef", err))
3898                                 }
3899                         }
3900                         var local124 uint16
3901                         {
3902                                 p := &local124
3903                                 *p = read16(r)
3904                         }
3905                         ((*(*(struct {
3906                                 Defs    []ItemDef
3907                                 Aliases []struct{ Alias, Orig string }
3908                         }))(obj)).Aliases) = make([]struct {
3909                                 Alias string
3910                                 Orig  string
3911                         }, local124)
3912                         for local125 := range (*(*(struct {
3913                                 Defs    []ItemDef
3914                                 Aliases []struct{ Alias, Orig string }
3915                         }))(obj)).Aliases {
3916                                 var local126 []uint8
3917                                 var local127 uint16
3918                                 {
3919                                         p := &local127
3920                                         *p = read16(r)
3921                                 }
3922                                 (local126) = make([]uint8, local127)
3923                                 {
3924                                         _, err := io.ReadFull(r, (local126)[:])
3925                                         chk(err)
3926                                 }
3927                                 ((((*(*(struct {
3928                                         Defs    []ItemDef
3929                                         Aliases []struct{ Alias, Orig string }
3930                                 }))(obj)).Aliases)[local125]).Alias) = string(local126)
3931                                 var local128 []uint8
3932                                 var local129 uint16
3933                                 {
3934                                         p := &local129
3935                                         *p = read16(r)
3936                                 }
3937                                 (local128) = make([]uint8, local129)
3938                                 {
3939                                         _, err := io.ReadFull(r, (local128)[:])
3940                                         chk(err)
3941                                 }
3942                                 ((((*(*(struct {
3943                                         Defs    []ItemDef
3944                                         Aliases []struct{ Alias, Orig string }
3945                                 }))(obj)).Aliases)[local125]).Orig) = string(local128)
3946                         }
3947                         chk(r.Close())
3948                 }
3949                 if r.N > 0 {
3950                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3951                 }
3952         }
3953 }
3954
3955 func (obj *ToCltPlaySound) Serialize(w io.Writer) {
3956         if err := pcall(func() {
3957                 ((*(*(struct {
3958                         ID      SoundID
3959                         Name    string
3960                         Gain    float32
3961                         SrcType SoundSrcType
3962                         Pos
3963                         SrcAOID   AOID
3964                         Loop      bool
3965                         Fade      float32
3966                         Pitch     float32
3967                         Ephemeral bool
3968                 }))(obj)).ID).Serialize(w)
3969         }); err != nil {
3970                 if err == io.EOF {
3971                         chk(io.EOF)
3972                 }
3973                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
3974         }
3975         if len(([]byte((*(*(struct {
3976                 ID      SoundID
3977                 Name    string
3978                 Gain    float32
3979                 SrcType SoundSrcType
3980                 Pos
3981                 SrcAOID   AOID
3982                 Loop      bool
3983                 Fade      float32
3984                 Pitch     float32
3985                 Ephemeral bool
3986         }))(obj)).Name))) > math.MaxUint16 {
3987                 chk(ErrTooLong)
3988         }
3989         {
3990                 x := uint16(len(([]byte((*(*(struct {
3991                         ID      SoundID
3992                         Name    string
3993                         Gain    float32
3994                         SrcType SoundSrcType
3995                         Pos
3996                         SrcAOID   AOID
3997                         Loop      bool
3998                         Fade      float32
3999                         Pitch     float32
4000                         Ephemeral bool
4001                 }))(obj)).Name))))
4002                 write16(w, uint16(x))
4003         }
4004         {
4005                 _, err := w.Write(([]byte((*(*(struct {
4006                         ID      SoundID
4007                         Name    string
4008                         Gain    float32
4009                         SrcType SoundSrcType
4010                         Pos
4011                         SrcAOID   AOID
4012                         Loop      bool
4013                         Fade      float32
4014                         Pitch     float32
4015                         Ephemeral bool
4016                 }))(obj)).Name))[:])
4017                 chk(err)
4018         }
4019         {
4020                 x := (*(*(struct {
4021                         ID      SoundID
4022                         Name    string
4023                         Gain    float32
4024                         SrcType SoundSrcType
4025                         Pos
4026                         SrcAOID   AOID
4027                         Loop      bool
4028                         Fade      float32
4029                         Pitch     float32
4030                         Ephemeral bool
4031                 }))(obj)).Gain
4032                 write32(w, math.Float32bits(x))
4033         }
4034         if err := pcall(func() {
4035                 ((*(*(struct {
4036                         ID      SoundID
4037                         Name    string
4038                         Gain    float32
4039                         SrcType SoundSrcType
4040                         Pos
4041                         SrcAOID   AOID
4042                         Loop      bool
4043                         Fade      float32
4044                         Pitch     float32
4045                         Ephemeral bool
4046                 }))(obj)).SrcType).Serialize(w)
4047         }); err != nil {
4048                 if err == io.EOF {
4049                         chk(io.EOF)
4050                 }
4051                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundSrcType", err))
4052         }
4053         if err := pcall(func() {
4054                 ((*(*(struct {
4055                         ID      SoundID
4056                         Name    string
4057                         Gain    float32
4058                         SrcType SoundSrcType
4059                         Pos
4060                         SrcAOID   AOID
4061                         Loop      bool
4062                         Fade      float32
4063                         Pitch     float32
4064                         Ephemeral bool
4065                 }))(obj)).Pos).Serialize(w)
4066         }); err != nil {
4067                 if err == io.EOF {
4068                         chk(io.EOF)
4069                 }
4070                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
4071         }
4072         if err := pcall(func() {
4073                 ((*(*(struct {
4074                         ID      SoundID
4075                         Name    string
4076                         Gain    float32
4077                         SrcType SoundSrcType
4078                         Pos
4079                         SrcAOID   AOID
4080                         Loop      bool
4081                         Fade      float32
4082                         Pitch     float32
4083                         Ephemeral bool
4084                 }))(obj)).SrcAOID).Serialize(w)
4085         }); err != nil {
4086                 if err == io.EOF {
4087                         chk(io.EOF)
4088                 }
4089                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
4090         }
4091         {
4092                 x := (*(*(struct {
4093                         ID      SoundID
4094                         Name    string
4095                         Gain    float32
4096                         SrcType SoundSrcType
4097                         Pos
4098                         SrcAOID   AOID
4099                         Loop      bool
4100                         Fade      float32
4101                         Pitch     float32
4102                         Ephemeral bool
4103                 }))(obj)).Loop
4104                 if x {
4105                         write8(w, 1)
4106                 } else {
4107                         write8(w, 0)
4108                 }
4109         }
4110         {
4111                 x := (*(*(struct {
4112                         ID      SoundID
4113                         Name    string
4114                         Gain    float32
4115                         SrcType SoundSrcType
4116                         Pos
4117                         SrcAOID   AOID
4118                         Loop      bool
4119                         Fade      float32
4120                         Pitch     float32
4121                         Ephemeral bool
4122                 }))(obj)).Fade
4123                 write32(w, math.Float32bits(x))
4124         }
4125         {
4126                 x := (*(*(struct {
4127                         ID      SoundID
4128                         Name    string
4129                         Gain    float32
4130                         SrcType SoundSrcType
4131                         Pos
4132                         SrcAOID   AOID
4133                         Loop      bool
4134                         Fade      float32
4135                         Pitch     float32
4136                         Ephemeral bool
4137                 }))(obj)).Pitch
4138                 write32(w, math.Float32bits(x))
4139         }
4140         {
4141                 x := (*(*(struct {
4142                         ID      SoundID
4143                         Name    string
4144                         Gain    float32
4145                         SrcType SoundSrcType
4146                         Pos
4147                         SrcAOID   AOID
4148                         Loop      bool
4149                         Fade      float32
4150                         Pitch     float32
4151                         Ephemeral bool
4152                 }))(obj)).Ephemeral
4153                 if x {
4154                         write8(w, 1)
4155                 } else {
4156                         write8(w, 0)
4157                 }
4158         }
4159 }
4160
4161 func (obj *ToCltPlaySound) Deserialize(r io.Reader) {
4162         if err := pcall(func() {
4163                 ((*(*(struct {
4164                         ID      SoundID
4165                         Name    string
4166                         Gain    float32
4167                         SrcType SoundSrcType
4168                         Pos
4169                         SrcAOID   AOID
4170                         Loop      bool
4171                         Fade      float32
4172                         Pitch     float32
4173                         Ephemeral bool
4174                 }))(obj)).ID).Deserialize(r)
4175         }); err != nil {
4176                 if err == io.EOF {
4177                         chk(io.EOF)
4178                 }
4179                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4180         }
4181         var local130 []uint8
4182         var local131 uint16
4183         {
4184                 p := &local131
4185                 *p = read16(r)
4186         }
4187         (local130) = make([]uint8, local131)
4188         {
4189                 _, err := io.ReadFull(r, (local130)[:])
4190                 chk(err)
4191         }
4192         ((*(*(struct {
4193                 ID      SoundID
4194                 Name    string
4195                 Gain    float32
4196                 SrcType SoundSrcType
4197                 Pos
4198                 SrcAOID   AOID
4199                 Loop      bool
4200                 Fade      float32
4201                 Pitch     float32
4202                 Ephemeral bool
4203         }))(obj)).Name) = string(local130)
4204         {
4205                 p := &(*(*(struct {
4206                         ID      SoundID
4207                         Name    string
4208                         Gain    float32
4209                         SrcType SoundSrcType
4210                         Pos
4211                         SrcAOID   AOID
4212                         Loop      bool
4213                         Fade      float32
4214                         Pitch     float32
4215                         Ephemeral bool
4216                 }))(obj)).Gain
4217                 *p = math.Float32frombits(read32(r))
4218         }
4219         if err := pcall(func() {
4220                 ((*(*(struct {
4221                         ID      SoundID
4222                         Name    string
4223                         Gain    float32
4224                         SrcType SoundSrcType
4225                         Pos
4226                         SrcAOID   AOID
4227                         Loop      bool
4228                         Fade      float32
4229                         Pitch     float32
4230                         Ephemeral bool
4231                 }))(obj)).SrcType).Deserialize(r)
4232         }); err != nil {
4233                 if err == io.EOF {
4234                         chk(io.EOF)
4235                 }
4236                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundSrcType", err))
4237         }
4238         if err := pcall(func() {
4239                 ((*(*(struct {
4240                         ID      SoundID
4241                         Name    string
4242                         Gain    float32
4243                         SrcType SoundSrcType
4244                         Pos
4245                         SrcAOID   AOID
4246                         Loop      bool
4247                         Fade      float32
4248                         Pitch     float32
4249                         Ephemeral bool
4250                 }))(obj)).Pos).Deserialize(r)
4251         }); err != nil {
4252                 if err == io.EOF {
4253                         chk(io.EOF)
4254                 }
4255                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
4256         }
4257         if err := pcall(func() {
4258                 ((*(*(struct {
4259                         ID      SoundID
4260                         Name    string
4261                         Gain    float32
4262                         SrcType SoundSrcType
4263                         Pos
4264                         SrcAOID   AOID
4265                         Loop      bool
4266                         Fade      float32
4267                         Pitch     float32
4268                         Ephemeral bool
4269                 }))(obj)).SrcAOID).Deserialize(r)
4270         }); err != nil {
4271                 if err == io.EOF {
4272                         chk(io.EOF)
4273                 }
4274                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
4275         }
4276         {
4277                 p := &(*(*(struct {
4278                         ID      SoundID
4279                         Name    string
4280                         Gain    float32
4281                         SrcType SoundSrcType
4282                         Pos
4283                         SrcAOID   AOID
4284                         Loop      bool
4285                         Fade      float32
4286                         Pitch     float32
4287                         Ephemeral bool
4288                 }))(obj)).Loop
4289                 switch n := read8(r); n {
4290                 case 0:
4291                         *p = false
4292                 case 1:
4293                         *p = true
4294                 default:
4295                         chk(fmt.Errorf("invalid bool: %d", n))
4296                 }
4297         }
4298         {
4299                 p := &(*(*(struct {
4300                         ID      SoundID
4301                         Name    string
4302                         Gain    float32
4303                         SrcType SoundSrcType
4304                         Pos
4305                         SrcAOID   AOID
4306                         Loop      bool
4307                         Fade      float32
4308                         Pitch     float32
4309                         Ephemeral bool
4310                 }))(obj)).Fade
4311                 *p = math.Float32frombits(read32(r))
4312         }
4313         {
4314                 p := &(*(*(struct {
4315                         ID      SoundID
4316                         Name    string
4317                         Gain    float32
4318                         SrcType SoundSrcType
4319                         Pos
4320                         SrcAOID   AOID
4321                         Loop      bool
4322                         Fade      float32
4323                         Pitch     float32
4324                         Ephemeral bool
4325                 }))(obj)).Pitch
4326                 *p = math.Float32frombits(read32(r))
4327         }
4328         {
4329                 p := &(*(*(struct {
4330                         ID      SoundID
4331                         Name    string
4332                         Gain    float32
4333                         SrcType SoundSrcType
4334                         Pos
4335                         SrcAOID   AOID
4336                         Loop      bool
4337                         Fade      float32
4338                         Pitch     float32
4339                         Ephemeral bool
4340                 }))(obj)).Ephemeral
4341                 switch n := read8(r); n {
4342                 case 0:
4343                         *p = false
4344                 case 1:
4345                         *p = true
4346                 default:
4347                         chk(fmt.Errorf("invalid bool: %d", n))
4348                 }
4349         }
4350 }
4351
4352 func (obj *ToCltStopSound) Serialize(w io.Writer) {
4353         if err := pcall(func() {
4354                 ((*(*(struct {
4355                         ID SoundID
4356                 }))(obj)).ID).Serialize(w)
4357         }); err != nil {
4358                 if err == io.EOF {
4359                         chk(io.EOF)
4360                 }
4361                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4362         }
4363 }
4364
4365 func (obj *ToCltStopSound) Deserialize(r io.Reader) {
4366         if err := pcall(func() {
4367                 ((*(*(struct {
4368                         ID SoundID
4369                 }))(obj)).ID).Deserialize(r)
4370         }); err != nil {
4371                 if err == io.EOF {
4372                         chk(io.EOF)
4373                 }
4374                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4375         }
4376 }
4377
4378 func (obj *ToCltPrivs) Serialize(w io.Writer) {
4379         if len(((*(*(struct {
4380                 Privs []string
4381         }))(obj)).Privs)) > math.MaxUint16 {
4382                 chk(ErrTooLong)
4383         }
4384         {
4385                 x := uint16(len(((*(*(struct {
4386                         Privs []string
4387                 }))(obj)).Privs)))
4388                 write16(w, uint16(x))
4389         }
4390         for local132 := range (*(*(struct {
4391                 Privs []string
4392         }))(obj)).Privs {
4393                 if len(([]byte(((*(*(struct {
4394                         Privs []string
4395                 }))(obj)).Privs)[local132]))) > math.MaxUint16 {
4396                         chk(ErrTooLong)
4397                 }
4398                 {
4399                         x := uint16(len(([]byte(((*(*(struct {
4400                                 Privs []string
4401                         }))(obj)).Privs)[local132]))))
4402                         write16(w, uint16(x))
4403                 }
4404                 {
4405                         _, err := w.Write(([]byte(((*(*(struct {
4406                                 Privs []string
4407                         }))(obj)).Privs)[local132]))[:])
4408                         chk(err)
4409                 }
4410         }
4411 }
4412
4413 func (obj *ToCltPrivs) Deserialize(r io.Reader) {
4414         var local133 uint16
4415         {
4416                 p := &local133
4417                 *p = read16(r)
4418         }
4419         ((*(*(struct {
4420                 Privs []string
4421         }))(obj)).Privs) = make([]string, local133)
4422         for local134 := range (*(*(struct {
4423                 Privs []string
4424         }))(obj)).Privs {
4425                 var local135 []uint8
4426                 var local136 uint16
4427                 {
4428                         p := &local136
4429                         *p = read16(r)
4430                 }
4431                 (local135) = make([]uint8, local136)
4432                 {
4433                         _, err := io.ReadFull(r, (local135)[:])
4434                         chk(err)
4435                 }
4436                 (((*(*(struct {
4437                         Privs []string
4438                 }))(obj)).Privs)[local134]) = string(local135)
4439         }
4440 }
4441
4442 func (obj *ToCltInvFormspec) Serialize(w io.Writer) {
4443         if len(([]byte((*(*(struct {
4444                 //mt:len32
4445                 Formspec string
4446         }))(obj)).Formspec))) > math.MaxUint32 {
4447                 chk(ErrTooLong)
4448         }
4449         {
4450                 x := uint32(len(([]byte((*(*(struct {
4451                         //mt:len32
4452                         Formspec string
4453                 }))(obj)).Formspec))))
4454                 write32(w, uint32(x))
4455         }
4456         {
4457                 _, err := w.Write(([]byte((*(*(struct {
4458                         //mt:len32
4459                         Formspec string
4460                 }))(obj)).Formspec))[:])
4461                 chk(err)
4462         }
4463 }
4464
4465 func (obj *ToCltInvFormspec) Deserialize(r io.Reader) {
4466         var local137 []uint8
4467         var local138 uint32
4468         {
4469                 p := &local138
4470                 *p = read32(r)
4471         }
4472         (local137) = make([]uint8, local138)
4473         {
4474                 _, err := io.ReadFull(r, (local137)[:])
4475                 chk(err)
4476         }
4477         ((*(*(struct {
4478                 //mt:len32
4479                 Formspec string
4480         }))(obj)).Formspec) = string(local137)
4481 }
4482
4483 func (obj *ToCltDetachedInv) Serialize(w io.Writer) {
4484         if len(([]byte((*(*(struct {
4485                 Name string
4486                 Keep bool
4487                 Len  uint16 // deprecated
4488
4489                 //mt:raw
4490                 Inv string
4491         }))(obj)).Name))) > math.MaxUint16 {
4492                 chk(ErrTooLong)
4493         }
4494         {
4495                 x := uint16(len(([]byte((*(*(struct {
4496                         Name string
4497                         Keep bool
4498                         Len  uint16 // deprecated
4499
4500                         //mt:raw
4501                         Inv string
4502                 }))(obj)).Name))))
4503                 write16(w, uint16(x))
4504         }
4505         {
4506                 _, err := w.Write(([]byte((*(*(struct {
4507                         Name string
4508                         Keep bool
4509                         Len  uint16 // deprecated
4510
4511                         //mt:raw
4512                         Inv string
4513                 }))(obj)).Name))[:])
4514                 chk(err)
4515         }
4516         {
4517                 x := (*(*(struct {
4518                         Name string
4519                         Keep bool
4520                         Len  uint16 // deprecated
4521
4522                         //mt:raw
4523                         Inv string
4524                 }))(obj)).Keep
4525                 if x {
4526                         write8(w, 1)
4527                 } else {
4528                         write8(w, 0)
4529                 }
4530         }
4531         {
4532                 x := (*(*(struct {
4533                         Name string
4534                         Keep bool
4535                         Len  uint16 // deprecated
4536
4537                         //mt:raw
4538                         Inv string
4539                 }))(obj)).Len
4540                 write16(w, uint16(x))
4541         }
4542         {
4543                 _, err := w.Write(([]byte((*(*(struct {
4544                         Name string
4545                         Keep bool
4546                         Len  uint16 // deprecated
4547
4548                         //mt:raw
4549                         Inv string
4550                 }))(obj)).Inv))[:])
4551                 chk(err)
4552         }
4553 }
4554
4555 func (obj *ToCltDetachedInv) Deserialize(r io.Reader) {
4556         var local139 []uint8
4557         var local140 uint16
4558         {
4559                 p := &local140
4560                 *p = read16(r)
4561         }
4562         (local139) = make([]uint8, local140)
4563         {
4564                 _, err := io.ReadFull(r, (local139)[:])
4565                 chk(err)
4566         }
4567         ((*(*(struct {
4568                 Name string
4569                 Keep bool
4570                 Len  uint16 // deprecated
4571
4572                 //mt:raw
4573                 Inv string
4574         }))(obj)).Name) = string(local139)
4575         {
4576                 p := &(*(*(struct {
4577                         Name string
4578                         Keep bool
4579                         Len  uint16 // deprecated
4580
4581                         //mt:raw
4582                         Inv string
4583                 }))(obj)).Keep
4584                 switch n := read8(r); n {
4585                 case 0:
4586                         *p = false
4587                 case 1:
4588                         *p = true
4589                 default:
4590                         chk(fmt.Errorf("invalid bool: %d", n))
4591                 }
4592         }
4593         {
4594                 p := &(*(*(struct {
4595                         Name string
4596                         Keep bool
4597                         Len  uint16 // deprecated
4598
4599                         //mt:raw
4600                         Inv string
4601                 }))(obj)).Len
4602                 *p = read16(r)
4603         }
4604         var local141 []uint8
4605         {
4606                 var err error
4607                 (local141), err = io.ReadAll(r)
4608                 chk(err)
4609         }
4610         ((*(*(struct {
4611                 Name string
4612                 Keep bool
4613                 Len  uint16 // deprecated
4614
4615                 //mt:raw
4616                 Inv string
4617         }))(obj)).Inv) = string(local141)
4618 }
4619
4620 func (obj *ToCltShowFormspec) Serialize(w io.Writer) {
4621         if len(([]byte((*(*(struct {
4622                 //mt:len32
4623                 Formspec string
4624
4625                 Formname string
4626         }))(obj)).Formspec))) > math.MaxUint32 {
4627                 chk(ErrTooLong)
4628         }
4629         {
4630                 x := uint32(len(([]byte((*(*(struct {
4631                         //mt:len32
4632                         Formspec string
4633
4634                         Formname string
4635                 }))(obj)).Formspec))))
4636                 write32(w, uint32(x))
4637         }
4638         {
4639                 _, err := w.Write(([]byte((*(*(struct {
4640                         //mt:len32
4641                         Formspec string
4642
4643                         Formname string
4644                 }))(obj)).Formspec))[:])
4645                 chk(err)
4646         }
4647         if len(([]byte((*(*(struct {
4648                 //mt:len32
4649                 Formspec string
4650
4651                 Formname string
4652         }))(obj)).Formname))) > math.MaxUint16 {
4653                 chk(ErrTooLong)
4654         }
4655         {
4656                 x := uint16(len(([]byte((*(*(struct {
4657                         //mt:len32
4658                         Formspec string
4659
4660                         Formname string
4661                 }))(obj)).Formname))))
4662                 write16(w, uint16(x))
4663         }
4664         {
4665                 _, err := w.Write(([]byte((*(*(struct {
4666                         //mt:len32
4667                         Formspec string
4668
4669                         Formname string
4670                 }))(obj)).Formname))[:])
4671                 chk(err)
4672         }
4673 }
4674
4675 func (obj *ToCltShowFormspec) Deserialize(r io.Reader) {
4676         var local142 []uint8
4677         var local143 uint32
4678         {
4679                 p := &local143
4680                 *p = read32(r)
4681         }
4682         (local142) = make([]uint8, local143)
4683         {
4684                 _, err := io.ReadFull(r, (local142)[:])
4685                 chk(err)
4686         }
4687         ((*(*(struct {
4688                 //mt:len32
4689                 Formspec string
4690
4691                 Formname string
4692         }))(obj)).Formspec) = string(local142)
4693         var local144 []uint8
4694         var local145 uint16
4695         {
4696                 p := &local145
4697                 *p = read16(r)
4698         }
4699         (local144) = make([]uint8, local145)
4700         {
4701                 _, err := io.ReadFull(r, (local144)[:])
4702                 chk(err)
4703         }
4704         ((*(*(struct {
4705                 //mt:len32
4706                 Formspec string
4707
4708                 Formname string
4709         }))(obj)).Formname) = string(local144)
4710 }
4711
4712 func (obj *ToCltMovement) Serialize(w io.Writer) {
4713         {
4714                 x := (*(*(struct {
4715                         DefaultAccel, AirAccel, FastAccel,
4716                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4717                         Fluidity, Smoothing, Sink,
4718                         Gravity float32
4719                 }))(obj)).DefaultAccel
4720                 write32(w, math.Float32bits(x))
4721         }
4722         {
4723                 x := (*(*(struct {
4724                         DefaultAccel, AirAccel, FastAccel,
4725                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4726                         Fluidity, Smoothing, Sink,
4727                         Gravity float32
4728                 }))(obj)).AirAccel
4729                 write32(w, math.Float32bits(x))
4730         }
4731         {
4732                 x := (*(*(struct {
4733                         DefaultAccel, AirAccel, FastAccel,
4734                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4735                         Fluidity, Smoothing, Sink,
4736                         Gravity float32
4737                 }))(obj)).FastAccel
4738                 write32(w, math.Float32bits(x))
4739         }
4740         {
4741                 x := (*(*(struct {
4742                         DefaultAccel, AirAccel, FastAccel,
4743                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4744                         Fluidity, Smoothing, Sink,
4745                         Gravity float32
4746                 }))(obj)).WalkSpeed
4747                 write32(w, math.Float32bits(x))
4748         }
4749         {
4750                 x := (*(*(struct {
4751                         DefaultAccel, AirAccel, FastAccel,
4752                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4753                         Fluidity, Smoothing, Sink,
4754                         Gravity float32
4755                 }))(obj)).CrouchSpeed
4756                 write32(w, math.Float32bits(x))
4757         }
4758         {
4759                 x := (*(*(struct {
4760                         DefaultAccel, AirAccel, FastAccel,
4761                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4762                         Fluidity, Smoothing, Sink,
4763                         Gravity float32
4764                 }))(obj)).FastSpeed
4765                 write32(w, math.Float32bits(x))
4766         }
4767         {
4768                 x := (*(*(struct {
4769                         DefaultAccel, AirAccel, FastAccel,
4770                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4771                         Fluidity, Smoothing, Sink,
4772                         Gravity float32
4773                 }))(obj)).ClimbSpeed
4774                 write32(w, math.Float32bits(x))
4775         }
4776         {
4777                 x := (*(*(struct {
4778                         DefaultAccel, AirAccel, FastAccel,
4779                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4780                         Fluidity, Smoothing, Sink,
4781                         Gravity float32
4782                 }))(obj)).JumpSpeed
4783                 write32(w, math.Float32bits(x))
4784         }
4785         {
4786                 x := (*(*(struct {
4787                         DefaultAccel, AirAccel, FastAccel,
4788                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4789                         Fluidity, Smoothing, Sink,
4790                         Gravity float32
4791                 }))(obj)).Fluidity
4792                 write32(w, math.Float32bits(x))
4793         }
4794         {
4795                 x := (*(*(struct {
4796                         DefaultAccel, AirAccel, FastAccel,
4797                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4798                         Fluidity, Smoothing, Sink,
4799                         Gravity float32
4800                 }))(obj)).Smoothing
4801                 write32(w, math.Float32bits(x))
4802         }
4803         {
4804                 x := (*(*(struct {
4805                         DefaultAccel, AirAccel, FastAccel,
4806                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4807                         Fluidity, Smoothing, Sink,
4808                         Gravity float32
4809                 }))(obj)).Sink
4810                 write32(w, math.Float32bits(x))
4811         }
4812         {
4813                 x := (*(*(struct {
4814                         DefaultAccel, AirAccel, FastAccel,
4815                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4816                         Fluidity, Smoothing, Sink,
4817                         Gravity float32
4818                 }))(obj)).Gravity
4819                 write32(w, math.Float32bits(x))
4820         }
4821 }
4822
4823 func (obj *ToCltMovement) Deserialize(r io.Reader) {
4824         {
4825                 p := &(*(*(struct {
4826                         DefaultAccel, AirAccel, FastAccel,
4827                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4828                         Fluidity, Smoothing, Sink,
4829                         Gravity float32
4830                 }))(obj)).DefaultAccel
4831                 *p = math.Float32frombits(read32(r))
4832         }
4833         {
4834                 p := &(*(*(struct {
4835                         DefaultAccel, AirAccel, FastAccel,
4836                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4837                         Fluidity, Smoothing, Sink,
4838                         Gravity float32
4839                 }))(obj)).AirAccel
4840                 *p = math.Float32frombits(read32(r))
4841         }
4842         {
4843                 p := &(*(*(struct {
4844                         DefaultAccel, AirAccel, FastAccel,
4845                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4846                         Fluidity, Smoothing, Sink,
4847                         Gravity float32
4848                 }))(obj)).FastAccel
4849                 *p = math.Float32frombits(read32(r))
4850         }
4851         {
4852                 p := &(*(*(struct {
4853                         DefaultAccel, AirAccel, FastAccel,
4854                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4855                         Fluidity, Smoothing, Sink,
4856                         Gravity float32
4857                 }))(obj)).WalkSpeed
4858                 *p = math.Float32frombits(read32(r))
4859         }
4860         {
4861                 p := &(*(*(struct {
4862                         DefaultAccel, AirAccel, FastAccel,
4863                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4864                         Fluidity, Smoothing, Sink,
4865                         Gravity float32
4866                 }))(obj)).CrouchSpeed
4867                 *p = math.Float32frombits(read32(r))
4868         }
4869         {
4870                 p := &(*(*(struct {
4871                         DefaultAccel, AirAccel, FastAccel,
4872                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4873                         Fluidity, Smoothing, Sink,
4874                         Gravity float32
4875                 }))(obj)).FastSpeed
4876                 *p = math.Float32frombits(read32(r))
4877         }
4878         {
4879                 p := &(*(*(struct {
4880                         DefaultAccel, AirAccel, FastAccel,
4881                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4882                         Fluidity, Smoothing, Sink,
4883                         Gravity float32
4884                 }))(obj)).ClimbSpeed
4885                 *p = math.Float32frombits(read32(r))
4886         }
4887         {
4888                 p := &(*(*(struct {
4889                         DefaultAccel, AirAccel, FastAccel,
4890                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4891                         Fluidity, Smoothing, Sink,
4892                         Gravity float32
4893                 }))(obj)).JumpSpeed
4894                 *p = math.Float32frombits(read32(r))
4895         }
4896         {
4897                 p := &(*(*(struct {
4898                         DefaultAccel, AirAccel, FastAccel,
4899                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4900                         Fluidity, Smoothing, Sink,
4901                         Gravity float32
4902                 }))(obj)).Fluidity
4903                 *p = math.Float32frombits(read32(r))
4904         }
4905         {
4906                 p := &(*(*(struct {
4907                         DefaultAccel, AirAccel, FastAccel,
4908                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4909                         Fluidity, Smoothing, Sink,
4910                         Gravity float32
4911                 }))(obj)).Smoothing
4912                 *p = math.Float32frombits(read32(r))
4913         }
4914         {
4915                 p := &(*(*(struct {
4916                         DefaultAccel, AirAccel, FastAccel,
4917                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4918                         Fluidity, Smoothing, Sink,
4919                         Gravity float32
4920                 }))(obj)).Sink
4921                 *p = math.Float32frombits(read32(r))
4922         }
4923         {
4924                 p := &(*(*(struct {
4925                         DefaultAccel, AirAccel, FastAccel,
4926                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4927                         Fluidity, Smoothing, Sink,
4928                         Gravity float32
4929                 }))(obj)).Gravity
4930                 *p = math.Float32frombits(read32(r))
4931         }
4932 }
4933
4934 func (obj *ToCltSpawnParticle) Serialize(w io.Writer) {
4935         for local146 := range (*(*(struct {
4936                 Pos, Vel, Acc  [3]float32
4937                 ExpirationTime float32 // in seconds.
4938                 Size           float32
4939                 Collide        bool
4940
4941                 //mt:len32
4942                 Texture
4943
4944                 Vertical    bool
4945                 CollisionRm bool
4946                 AnimParams  TileAnim
4947                 Glow        uint8
4948                 AOCollision bool
4949                 NodeParam0  Content
4950                 NodeParam2  uint8
4951                 NodeTile    uint8
4952         }))(obj)).Pos {
4953                 {
4954                         x := ((*(*(struct {
4955                                 Pos, Vel, Acc  [3]float32
4956                                 ExpirationTime float32 // in seconds.
4957                                 Size           float32
4958                                 Collide        bool
4959
4960                                 //mt:len32
4961                                 Texture
4962
4963                                 Vertical    bool
4964                                 CollisionRm bool
4965                                 AnimParams  TileAnim
4966                                 Glow        uint8
4967                                 AOCollision bool
4968                                 NodeParam0  Content
4969                                 NodeParam2  uint8
4970                                 NodeTile    uint8
4971                         }))(obj)).Pos)[local146]
4972                         write32(w, math.Float32bits(x))
4973                 }
4974         }
4975         for local147 := range (*(*(struct {
4976                 Pos, Vel, Acc  [3]float32
4977                 ExpirationTime float32 // in seconds.
4978                 Size           float32
4979                 Collide        bool
4980
4981                 //mt:len32
4982                 Texture
4983
4984                 Vertical    bool
4985                 CollisionRm bool
4986                 AnimParams  TileAnim
4987                 Glow        uint8
4988                 AOCollision bool
4989                 NodeParam0  Content
4990                 NodeParam2  uint8
4991                 NodeTile    uint8
4992         }))(obj)).Vel {
4993                 {
4994                         x := ((*(*(struct {
4995                                 Pos, Vel, Acc  [3]float32
4996                                 ExpirationTime float32 // in seconds.
4997                                 Size           float32
4998                                 Collide        bool
4999
5000                                 //mt:len32
5001                                 Texture
5002
5003                                 Vertical    bool
5004                                 CollisionRm bool
5005                                 AnimParams  TileAnim
5006                                 Glow        uint8
5007                                 AOCollision bool
5008                                 NodeParam0  Content
5009                                 NodeParam2  uint8
5010                                 NodeTile    uint8
5011                         }))(obj)).Vel)[local147]
5012                         write32(w, math.Float32bits(x))
5013                 }
5014         }
5015         for local148 := range (*(*(struct {
5016                 Pos, Vel, Acc  [3]float32
5017                 ExpirationTime float32 // in seconds.
5018                 Size           float32
5019                 Collide        bool
5020
5021                 //mt:len32
5022                 Texture
5023
5024                 Vertical    bool
5025                 CollisionRm bool
5026                 AnimParams  TileAnim
5027                 Glow        uint8
5028                 AOCollision bool
5029                 NodeParam0  Content
5030                 NodeParam2  uint8
5031                 NodeTile    uint8
5032         }))(obj)).Acc {
5033                 {
5034                         x := ((*(*(struct {
5035                                 Pos, Vel, Acc  [3]float32
5036                                 ExpirationTime float32 // in seconds.
5037                                 Size           float32
5038                                 Collide        bool
5039
5040                                 //mt:len32
5041                                 Texture
5042
5043                                 Vertical    bool
5044                                 CollisionRm bool
5045                                 AnimParams  TileAnim
5046                                 Glow        uint8
5047                                 AOCollision bool
5048                                 NodeParam0  Content
5049                                 NodeParam2  uint8
5050                                 NodeTile    uint8
5051                         }))(obj)).Acc)[local148]
5052                         write32(w, math.Float32bits(x))
5053                 }
5054         }
5055         {
5056                 x := (*(*(struct {
5057                         Pos, Vel, Acc  [3]float32
5058                         ExpirationTime float32 // in seconds.
5059                         Size           float32
5060                         Collide        bool
5061
5062                         //mt:len32
5063                         Texture
5064
5065                         Vertical    bool
5066                         CollisionRm bool
5067                         AnimParams  TileAnim
5068                         Glow        uint8
5069                         AOCollision bool
5070                         NodeParam0  Content
5071                         NodeParam2  uint8
5072                         NodeTile    uint8
5073                 }))(obj)).ExpirationTime
5074                 write32(w, math.Float32bits(x))
5075         }
5076         {
5077                 x := (*(*(struct {
5078                         Pos, Vel, Acc  [3]float32
5079                         ExpirationTime float32 // in seconds.
5080                         Size           float32
5081                         Collide        bool
5082
5083                         //mt:len32
5084                         Texture
5085
5086                         Vertical    bool
5087                         CollisionRm bool
5088                         AnimParams  TileAnim
5089                         Glow        uint8
5090                         AOCollision bool
5091                         NodeParam0  Content
5092                         NodeParam2  uint8
5093                         NodeTile    uint8
5094                 }))(obj)).Size
5095                 write32(w, math.Float32bits(x))
5096         }
5097         {
5098                 x := (*(*(struct {
5099                         Pos, Vel, Acc  [3]float32
5100                         ExpirationTime float32 // in seconds.
5101                         Size           float32
5102                         Collide        bool
5103
5104                         //mt:len32
5105                         Texture
5106
5107                         Vertical    bool
5108                         CollisionRm bool
5109                         AnimParams  TileAnim
5110                         Glow        uint8
5111                         AOCollision bool
5112                         NodeParam0  Content
5113                         NodeParam2  uint8
5114                         NodeTile    uint8
5115                 }))(obj)).Collide
5116                 if x {
5117                         write8(w, 1)
5118                 } else {
5119                         write8(w, 0)
5120                 }
5121         }
5122         if len(([]byte(*(*string)(&((*(*(struct {
5123                 Pos, Vel, Acc  [3]float32
5124                 ExpirationTime float32 // in seconds.
5125                 Size           float32
5126                 Collide        bool
5127
5128                 //mt:len32
5129                 Texture
5130
5131                 Vertical    bool
5132                 CollisionRm bool
5133                 AnimParams  TileAnim
5134                 Glow        uint8
5135                 AOCollision bool
5136                 NodeParam0  Content
5137                 NodeParam2  uint8
5138                 NodeTile    uint8
5139         }))(obj)).Texture))))) > math.MaxUint32 {
5140                 chk(ErrTooLong)
5141         }
5142         {
5143                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5144                         Pos, Vel, Acc  [3]float32
5145                         ExpirationTime float32 // in seconds.
5146                         Size           float32
5147                         Collide        bool
5148
5149                         //mt:len32
5150                         Texture
5151
5152                         Vertical    bool
5153                         CollisionRm bool
5154                         AnimParams  TileAnim
5155                         Glow        uint8
5156                         AOCollision bool
5157                         NodeParam0  Content
5158                         NodeParam2  uint8
5159                         NodeTile    uint8
5160                 }))(obj)).Texture))))))
5161                 write32(w, uint32(x))
5162         }
5163         {
5164                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5165                         Pos, Vel, Acc  [3]float32
5166                         ExpirationTime float32 // in seconds.
5167                         Size           float32
5168                         Collide        bool
5169
5170                         //mt:len32
5171                         Texture
5172
5173                         Vertical    bool
5174                         CollisionRm bool
5175                         AnimParams  TileAnim
5176                         Glow        uint8
5177                         AOCollision bool
5178                         NodeParam0  Content
5179                         NodeParam2  uint8
5180                         NodeTile    uint8
5181                 }))(obj)).Texture))))[:])
5182                 chk(err)
5183         }
5184         {
5185                 x := (*(*(struct {
5186                         Pos, Vel, Acc  [3]float32
5187                         ExpirationTime float32 // in seconds.
5188                         Size           float32
5189                         Collide        bool
5190
5191                         //mt:len32
5192                         Texture
5193
5194                         Vertical    bool
5195                         CollisionRm bool
5196                         AnimParams  TileAnim
5197                         Glow        uint8
5198                         AOCollision bool
5199                         NodeParam0  Content
5200                         NodeParam2  uint8
5201                         NodeTile    uint8
5202                 }))(obj)).Vertical
5203                 if x {
5204                         write8(w, 1)
5205                 } else {
5206                         write8(w, 0)
5207                 }
5208         }
5209         {
5210                 x := (*(*(struct {
5211                         Pos, Vel, Acc  [3]float32
5212                         ExpirationTime float32 // in seconds.
5213                         Size           float32
5214                         Collide        bool
5215
5216                         //mt:len32
5217                         Texture
5218
5219                         Vertical    bool
5220                         CollisionRm bool
5221                         AnimParams  TileAnim
5222                         Glow        uint8
5223                         AOCollision bool
5224                         NodeParam0  Content
5225                         NodeParam2  uint8
5226                         NodeTile    uint8
5227                 }))(obj)).CollisionRm
5228                 if x {
5229                         write8(w, 1)
5230                 } else {
5231                         write8(w, 0)
5232                 }
5233         }
5234         if err := pcall(func() {
5235                 ((*(*(struct {
5236                         Pos, Vel, Acc  [3]float32
5237                         ExpirationTime float32 // in seconds.
5238                         Size           float32
5239                         Collide        bool
5240
5241                         //mt:len32
5242                         Texture
5243
5244                         Vertical    bool
5245                         CollisionRm bool
5246                         AnimParams  TileAnim
5247                         Glow        uint8
5248                         AOCollision bool
5249                         NodeParam0  Content
5250                         NodeParam2  uint8
5251                         NodeTile    uint8
5252                 }))(obj)).AnimParams).Serialize(w)
5253         }); err != nil {
5254                 if err == io.EOF {
5255                         chk(io.EOF)
5256                 }
5257                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
5258         }
5259         {
5260                 x := (*(*(struct {
5261                         Pos, Vel, Acc  [3]float32
5262                         ExpirationTime float32 // in seconds.
5263                         Size           float32
5264                         Collide        bool
5265
5266                         //mt:len32
5267                         Texture
5268
5269                         Vertical    bool
5270                         CollisionRm bool
5271                         AnimParams  TileAnim
5272                         Glow        uint8
5273                         AOCollision bool
5274                         NodeParam0  Content
5275                         NodeParam2  uint8
5276                         NodeTile    uint8
5277                 }))(obj)).Glow
5278                 write8(w, uint8(x))
5279         }
5280         {
5281                 x := (*(*(struct {
5282                         Pos, Vel, Acc  [3]float32
5283                         ExpirationTime float32 // in seconds.
5284                         Size           float32
5285                         Collide        bool
5286
5287                         //mt:len32
5288                         Texture
5289
5290                         Vertical    bool
5291                         CollisionRm bool
5292                         AnimParams  TileAnim
5293                         Glow        uint8
5294                         AOCollision bool
5295                         NodeParam0  Content
5296                         NodeParam2  uint8
5297                         NodeTile    uint8
5298                 }))(obj)).AOCollision
5299                 if x {
5300                         write8(w, 1)
5301                 } else {
5302                         write8(w, 0)
5303                 }
5304         }
5305         if err := pcall(func() {
5306                 ((*(*(struct {
5307                         Pos, Vel, Acc  [3]float32
5308                         ExpirationTime float32 // in seconds.
5309                         Size           float32
5310                         Collide        bool
5311
5312                         //mt:len32
5313                         Texture
5314
5315                         Vertical    bool
5316                         CollisionRm bool
5317                         AnimParams  TileAnim
5318                         Glow        uint8
5319                         AOCollision bool
5320                         NodeParam0  Content
5321                         NodeParam2  uint8
5322                         NodeTile    uint8
5323                 }))(obj)).NodeParam0).Serialize(w)
5324         }); err != nil {
5325                 if err == io.EOF {
5326                         chk(io.EOF)
5327                 }
5328                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
5329         }
5330         {
5331                 x := (*(*(struct {
5332                         Pos, Vel, Acc  [3]float32
5333                         ExpirationTime float32 // in seconds.
5334                         Size           float32
5335                         Collide        bool
5336
5337                         //mt:len32
5338                         Texture
5339
5340                         Vertical    bool
5341                         CollisionRm bool
5342                         AnimParams  TileAnim
5343                         Glow        uint8
5344                         AOCollision bool
5345                         NodeParam0  Content
5346                         NodeParam2  uint8
5347                         NodeTile    uint8
5348                 }))(obj)).NodeParam2
5349                 write8(w, uint8(x))
5350         }
5351         {
5352                 x := (*(*(struct {
5353                         Pos, Vel, Acc  [3]float32
5354                         ExpirationTime float32 // in seconds.
5355                         Size           float32
5356                         Collide        bool
5357
5358                         //mt:len32
5359                         Texture
5360
5361                         Vertical    bool
5362                         CollisionRm bool
5363                         AnimParams  TileAnim
5364                         Glow        uint8
5365                         AOCollision bool
5366                         NodeParam0  Content
5367                         NodeParam2  uint8
5368                         NodeTile    uint8
5369                 }))(obj)).NodeTile
5370                 write8(w, uint8(x))
5371         }
5372 }
5373
5374 func (obj *ToCltSpawnParticle) Deserialize(r io.Reader) {
5375         for local149 := range (*(*(struct {
5376                 Pos, Vel, Acc  [3]float32
5377                 ExpirationTime float32 // in seconds.
5378                 Size           float32
5379                 Collide        bool
5380
5381                 //mt:len32
5382                 Texture
5383
5384                 Vertical    bool
5385                 CollisionRm bool
5386                 AnimParams  TileAnim
5387                 Glow        uint8
5388                 AOCollision bool
5389                 NodeParam0  Content
5390                 NodeParam2  uint8
5391                 NodeTile    uint8
5392         }))(obj)).Pos {
5393                 {
5394                         p := &((*(*(struct {
5395                                 Pos, Vel, Acc  [3]float32
5396                                 ExpirationTime float32 // in seconds.
5397                                 Size           float32
5398                                 Collide        bool
5399
5400                                 //mt:len32
5401                                 Texture
5402
5403                                 Vertical    bool
5404                                 CollisionRm bool
5405                                 AnimParams  TileAnim
5406                                 Glow        uint8
5407                                 AOCollision bool
5408                                 NodeParam0  Content
5409                                 NodeParam2  uint8
5410                                 NodeTile    uint8
5411                         }))(obj)).Pos)[local149]
5412                         *p = math.Float32frombits(read32(r))
5413                 }
5414         }
5415         for local150 := range (*(*(struct {
5416                 Pos, Vel, Acc  [3]float32
5417                 ExpirationTime float32 // in seconds.
5418                 Size           float32
5419                 Collide        bool
5420
5421                 //mt:len32
5422                 Texture
5423
5424                 Vertical    bool
5425                 CollisionRm bool
5426                 AnimParams  TileAnim
5427                 Glow        uint8
5428                 AOCollision bool
5429                 NodeParam0  Content
5430                 NodeParam2  uint8
5431                 NodeTile    uint8
5432         }))(obj)).Vel {
5433                 {
5434                         p := &((*(*(struct {
5435                                 Pos, Vel, Acc  [3]float32
5436                                 ExpirationTime float32 // in seconds.
5437                                 Size           float32
5438                                 Collide        bool
5439
5440                                 //mt:len32
5441                                 Texture
5442
5443                                 Vertical    bool
5444                                 CollisionRm bool
5445                                 AnimParams  TileAnim
5446                                 Glow        uint8
5447                                 AOCollision bool
5448                                 NodeParam0  Content
5449                                 NodeParam2  uint8
5450                                 NodeTile    uint8
5451                         }))(obj)).Vel)[local150]
5452                         *p = math.Float32frombits(read32(r))
5453                 }
5454         }
5455         for local151 := range (*(*(struct {
5456                 Pos, Vel, Acc  [3]float32
5457                 ExpirationTime float32 // in seconds.
5458                 Size           float32
5459                 Collide        bool
5460
5461                 //mt:len32
5462                 Texture
5463
5464                 Vertical    bool
5465                 CollisionRm bool
5466                 AnimParams  TileAnim
5467                 Glow        uint8
5468                 AOCollision bool
5469                 NodeParam0  Content
5470                 NodeParam2  uint8
5471                 NodeTile    uint8
5472         }))(obj)).Acc {
5473                 {
5474                         p := &((*(*(struct {
5475                                 Pos, Vel, Acc  [3]float32
5476                                 ExpirationTime float32 // in seconds.
5477                                 Size           float32
5478                                 Collide        bool
5479
5480                                 //mt:len32
5481                                 Texture
5482
5483                                 Vertical    bool
5484                                 CollisionRm bool
5485                                 AnimParams  TileAnim
5486                                 Glow        uint8
5487                                 AOCollision bool
5488                                 NodeParam0  Content
5489                                 NodeParam2  uint8
5490                                 NodeTile    uint8
5491                         }))(obj)).Acc)[local151]
5492                         *p = math.Float32frombits(read32(r))
5493                 }
5494         }
5495         {
5496                 p := &(*(*(struct {
5497                         Pos, Vel, Acc  [3]float32
5498                         ExpirationTime float32 // in seconds.
5499                         Size           float32
5500                         Collide        bool
5501
5502                         //mt:len32
5503                         Texture
5504
5505                         Vertical    bool
5506                         CollisionRm bool
5507                         AnimParams  TileAnim
5508                         Glow        uint8
5509                         AOCollision bool
5510                         NodeParam0  Content
5511                         NodeParam2  uint8
5512                         NodeTile    uint8
5513                 }))(obj)).ExpirationTime
5514                 *p = math.Float32frombits(read32(r))
5515         }
5516         {
5517                 p := &(*(*(struct {
5518                         Pos, Vel, Acc  [3]float32
5519                         ExpirationTime float32 // in seconds.
5520                         Size           float32
5521                         Collide        bool
5522
5523                         //mt:len32
5524                         Texture
5525
5526                         Vertical    bool
5527                         CollisionRm bool
5528                         AnimParams  TileAnim
5529                         Glow        uint8
5530                         AOCollision bool
5531                         NodeParam0  Content
5532                         NodeParam2  uint8
5533                         NodeTile    uint8
5534                 }))(obj)).Size
5535                 *p = math.Float32frombits(read32(r))
5536         }
5537         {
5538                 p := &(*(*(struct {
5539                         Pos, Vel, Acc  [3]float32
5540                         ExpirationTime float32 // in seconds.
5541                         Size           float32
5542                         Collide        bool
5543
5544                         //mt:len32
5545                         Texture
5546
5547                         Vertical    bool
5548                         CollisionRm bool
5549                         AnimParams  TileAnim
5550                         Glow        uint8
5551                         AOCollision bool
5552                         NodeParam0  Content
5553                         NodeParam2  uint8
5554                         NodeTile    uint8
5555                 }))(obj)).Collide
5556                 switch n := read8(r); n {
5557                 case 0:
5558                         *p = false
5559                 case 1:
5560                         *p = true
5561                 default:
5562                         chk(fmt.Errorf("invalid bool: %d", n))
5563                 }
5564         }
5565         var local152 []uint8
5566         var local153 uint32
5567         {
5568                 p := &local153
5569                 *p = read32(r)
5570         }
5571         (local152) = make([]uint8, local153)
5572         {
5573                 _, err := io.ReadFull(r, (local152)[:])
5574                 chk(err)
5575         }
5576         (*(*string)(&((*(*(struct {
5577                 Pos, Vel, Acc  [3]float32
5578                 ExpirationTime float32 // in seconds.
5579                 Size           float32
5580                 Collide        bool
5581
5582                 //mt:len32
5583                 Texture
5584
5585                 Vertical    bool
5586                 CollisionRm bool
5587                 AnimParams  TileAnim
5588                 Glow        uint8
5589                 AOCollision bool
5590                 NodeParam0  Content
5591                 NodeParam2  uint8
5592                 NodeTile    uint8
5593         }))(obj)).Texture))) = string(local152)
5594         {
5595                 p := &(*(*(struct {
5596                         Pos, Vel, Acc  [3]float32
5597                         ExpirationTime float32 // in seconds.
5598                         Size           float32
5599                         Collide        bool
5600
5601                         //mt:len32
5602                         Texture
5603
5604                         Vertical    bool
5605                         CollisionRm bool
5606                         AnimParams  TileAnim
5607                         Glow        uint8
5608                         AOCollision bool
5609                         NodeParam0  Content
5610                         NodeParam2  uint8
5611                         NodeTile    uint8
5612                 }))(obj)).Vertical
5613                 switch n := read8(r); n {
5614                 case 0:
5615                         *p = false
5616                 case 1:
5617                         *p = true
5618                 default:
5619                         chk(fmt.Errorf("invalid bool: %d", n))
5620                 }
5621         }
5622         {
5623                 p := &(*(*(struct {
5624                         Pos, Vel, Acc  [3]float32
5625                         ExpirationTime float32 // in seconds.
5626                         Size           float32
5627                         Collide        bool
5628
5629                         //mt:len32
5630                         Texture
5631
5632                         Vertical    bool
5633                         CollisionRm bool
5634                         AnimParams  TileAnim
5635                         Glow        uint8
5636                         AOCollision bool
5637                         NodeParam0  Content
5638                         NodeParam2  uint8
5639                         NodeTile    uint8
5640                 }))(obj)).CollisionRm
5641                 switch n := read8(r); n {
5642                 case 0:
5643                         *p = false
5644                 case 1:
5645                         *p = true
5646                 default:
5647                         chk(fmt.Errorf("invalid bool: %d", n))
5648                 }
5649         }
5650         if err := pcall(func() {
5651                 ((*(*(struct {
5652                         Pos, Vel, Acc  [3]float32
5653                         ExpirationTime float32 // in seconds.
5654                         Size           float32
5655                         Collide        bool
5656
5657                         //mt:len32
5658                         Texture
5659
5660                         Vertical    bool
5661                         CollisionRm bool
5662                         AnimParams  TileAnim
5663                         Glow        uint8
5664                         AOCollision bool
5665                         NodeParam0  Content
5666                         NodeParam2  uint8
5667                         NodeTile    uint8
5668                 }))(obj)).AnimParams).Deserialize(r)
5669         }); err != nil {
5670                 if err == io.EOF {
5671                         chk(io.EOF)
5672                 }
5673                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
5674         }
5675         {
5676                 p := &(*(*(struct {
5677                         Pos, Vel, Acc  [3]float32
5678                         ExpirationTime float32 // in seconds.
5679                         Size           float32
5680                         Collide        bool
5681
5682                         //mt:len32
5683                         Texture
5684
5685                         Vertical    bool
5686                         CollisionRm bool
5687                         AnimParams  TileAnim
5688                         Glow        uint8
5689                         AOCollision bool
5690                         NodeParam0  Content
5691                         NodeParam2  uint8
5692                         NodeTile    uint8
5693                 }))(obj)).Glow
5694                 *p = read8(r)
5695         }
5696         {
5697                 p := &(*(*(struct {
5698                         Pos, Vel, Acc  [3]float32
5699                         ExpirationTime float32 // in seconds.
5700                         Size           float32
5701                         Collide        bool
5702
5703                         //mt:len32
5704                         Texture
5705
5706                         Vertical    bool
5707                         CollisionRm bool
5708                         AnimParams  TileAnim
5709                         Glow        uint8
5710                         AOCollision bool
5711                         NodeParam0  Content
5712                         NodeParam2  uint8
5713                         NodeTile    uint8
5714                 }))(obj)).AOCollision
5715                 switch n := read8(r); n {
5716                 case 0:
5717                         *p = false
5718                 case 1:
5719                         *p = true
5720                 default:
5721                         chk(fmt.Errorf("invalid bool: %d", n))
5722                 }
5723         }
5724         if err := pcall(func() {
5725                 ((*(*(struct {
5726                         Pos, Vel, Acc  [3]float32
5727                         ExpirationTime float32 // in seconds.
5728                         Size           float32
5729                         Collide        bool
5730
5731                         //mt:len32
5732                         Texture
5733
5734                         Vertical    bool
5735                         CollisionRm bool
5736                         AnimParams  TileAnim
5737                         Glow        uint8
5738                         AOCollision bool
5739                         NodeParam0  Content
5740                         NodeParam2  uint8
5741                         NodeTile    uint8
5742                 }))(obj)).NodeParam0).Deserialize(r)
5743         }); err != nil {
5744                 if err == io.EOF {
5745                         chk(io.EOF)
5746                 }
5747                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
5748         }
5749         {
5750                 p := &(*(*(struct {
5751                         Pos, Vel, Acc  [3]float32
5752                         ExpirationTime float32 // in seconds.
5753                         Size           float32
5754                         Collide        bool
5755
5756                         //mt:len32
5757                         Texture
5758
5759                         Vertical    bool
5760                         CollisionRm bool
5761                         AnimParams  TileAnim
5762                         Glow        uint8
5763                         AOCollision bool
5764                         NodeParam0  Content
5765                         NodeParam2  uint8
5766                         NodeTile    uint8
5767                 }))(obj)).NodeParam2
5768                 *p = read8(r)
5769         }
5770         {
5771                 p := &(*(*(struct {
5772                         Pos, Vel, Acc  [3]float32
5773                         ExpirationTime float32 // in seconds.
5774                         Size           float32
5775                         Collide        bool
5776
5777                         //mt:len32
5778                         Texture
5779
5780                         Vertical    bool
5781                         CollisionRm bool
5782                         AnimParams  TileAnim
5783                         Glow        uint8
5784                         AOCollision bool
5785                         NodeParam0  Content
5786                         NodeParam2  uint8
5787                         NodeTile    uint8
5788                 }))(obj)).NodeTile
5789                 *p = read8(r)
5790         }
5791 }
5792
5793 func (obj *ToCltAddParticleSpawner) Serialize(w io.Writer) {
5794         {
5795                 x := (*(*(struct {
5796                         Amount         uint16
5797                         Duration       float32
5798                         Pos, Vel, Acc  [2][3]float32
5799                         ExpirationTime [2]float32 // in seconds.
5800                         Size           [2]float32
5801                         Collide        bool
5802
5803                         //mt:len32
5804                         Texture
5805
5806                         ID           ParticleSpawnerID
5807                         Vertical     bool
5808                         CollisionRm  bool
5809                         AttachedAOID AOID
5810                         AnimParams   TileAnim
5811                         Glow         uint8
5812                         AOCollision  bool
5813                         NodeParam0   Content
5814                         NodeParam2   uint8
5815                         NodeTile     uint8
5816                 }))(obj)).Amount
5817                 write16(w, uint16(x))
5818         }
5819         {
5820                 x := (*(*(struct {
5821                         Amount         uint16
5822                         Duration       float32
5823                         Pos, Vel, Acc  [2][3]float32
5824                         ExpirationTime [2]float32 // in seconds.
5825                         Size           [2]float32
5826                         Collide        bool
5827
5828                         //mt:len32
5829                         Texture
5830
5831                         ID           ParticleSpawnerID
5832                         Vertical     bool
5833                         CollisionRm  bool
5834                         AttachedAOID AOID
5835                         AnimParams   TileAnim
5836                         Glow         uint8
5837                         AOCollision  bool
5838                         NodeParam0   Content
5839                         NodeParam2   uint8
5840                         NodeTile     uint8
5841                 }))(obj)).Duration
5842                 write32(w, math.Float32bits(x))
5843         }
5844         for local154 := range (*(*(struct {
5845                 Amount         uint16
5846                 Duration       float32
5847                 Pos, Vel, Acc  [2][3]float32
5848                 ExpirationTime [2]float32 // in seconds.
5849                 Size           [2]float32
5850                 Collide        bool
5851
5852                 //mt:len32
5853                 Texture
5854
5855                 ID           ParticleSpawnerID
5856                 Vertical     bool
5857                 CollisionRm  bool
5858                 AttachedAOID AOID
5859                 AnimParams   TileAnim
5860                 Glow         uint8
5861                 AOCollision  bool
5862                 NodeParam0   Content
5863                 NodeParam2   uint8
5864                 NodeTile     uint8
5865         }))(obj)).Pos {
5866                 for local155 := range ((*(*(struct {
5867                         Amount         uint16
5868                         Duration       float32
5869                         Pos, Vel, Acc  [2][3]float32
5870                         ExpirationTime [2]float32 // in seconds.
5871                         Size           [2]float32
5872                         Collide        bool
5873
5874                         //mt:len32
5875                         Texture
5876
5877                         ID           ParticleSpawnerID
5878                         Vertical     bool
5879                         CollisionRm  bool
5880                         AttachedAOID AOID
5881                         AnimParams   TileAnim
5882                         Glow         uint8
5883                         AOCollision  bool
5884                         NodeParam0   Content
5885                         NodeParam2   uint8
5886                         NodeTile     uint8
5887                 }))(obj)).Pos)[local154] {
5888                         {
5889                                 x := (((*(*(struct {
5890                                         Amount         uint16
5891                                         Duration       float32
5892                                         Pos, Vel, Acc  [2][3]float32
5893                                         ExpirationTime [2]float32 // in seconds.
5894                                         Size           [2]float32
5895                                         Collide        bool
5896
5897                                         //mt:len32
5898                                         Texture
5899
5900                                         ID           ParticleSpawnerID
5901                                         Vertical     bool
5902                                         CollisionRm  bool
5903                                         AttachedAOID AOID
5904                                         AnimParams   TileAnim
5905                                         Glow         uint8
5906                                         AOCollision  bool
5907                                         NodeParam0   Content
5908                                         NodeParam2   uint8
5909                                         NodeTile     uint8
5910                                 }))(obj)).Pos)[local154])[local155]
5911                                 write32(w, math.Float32bits(x))
5912                         }
5913                 }
5914         }
5915         for local156 := range (*(*(struct {
5916                 Amount         uint16
5917                 Duration       float32
5918                 Pos, Vel, Acc  [2][3]float32
5919                 ExpirationTime [2]float32 // in seconds.
5920                 Size           [2]float32
5921                 Collide        bool
5922
5923                 //mt:len32
5924                 Texture
5925
5926                 ID           ParticleSpawnerID
5927                 Vertical     bool
5928                 CollisionRm  bool
5929                 AttachedAOID AOID
5930                 AnimParams   TileAnim
5931                 Glow         uint8
5932                 AOCollision  bool
5933                 NodeParam0   Content
5934                 NodeParam2   uint8
5935                 NodeTile     uint8
5936         }))(obj)).Vel {
5937                 for local157 := range ((*(*(struct {
5938                         Amount         uint16
5939                         Duration       float32
5940                         Pos, Vel, Acc  [2][3]float32
5941                         ExpirationTime [2]float32 // in seconds.
5942                         Size           [2]float32
5943                         Collide        bool
5944
5945                         //mt:len32
5946                         Texture
5947
5948                         ID           ParticleSpawnerID
5949                         Vertical     bool
5950                         CollisionRm  bool
5951                         AttachedAOID AOID
5952                         AnimParams   TileAnim
5953                         Glow         uint8
5954                         AOCollision  bool
5955                         NodeParam0   Content
5956                         NodeParam2   uint8
5957                         NodeTile     uint8
5958                 }))(obj)).Vel)[local156] {
5959                         {
5960                                 x := (((*(*(struct {
5961                                         Amount         uint16
5962                                         Duration       float32
5963                                         Pos, Vel, Acc  [2][3]float32
5964                                         ExpirationTime [2]float32 // in seconds.
5965                                         Size           [2]float32
5966                                         Collide        bool
5967
5968                                         //mt:len32
5969                                         Texture
5970
5971                                         ID           ParticleSpawnerID
5972                                         Vertical     bool
5973                                         CollisionRm  bool
5974                                         AttachedAOID AOID
5975                                         AnimParams   TileAnim
5976                                         Glow         uint8
5977                                         AOCollision  bool
5978                                         NodeParam0   Content
5979                                         NodeParam2   uint8
5980                                         NodeTile     uint8
5981                                 }))(obj)).Vel)[local156])[local157]
5982                                 write32(w, math.Float32bits(x))
5983                         }
5984                 }
5985         }
5986         for local158 := range (*(*(struct {
5987                 Amount         uint16
5988                 Duration       float32
5989                 Pos, Vel, Acc  [2][3]float32
5990                 ExpirationTime [2]float32 // in seconds.
5991                 Size           [2]float32
5992                 Collide        bool
5993
5994                 //mt:len32
5995                 Texture
5996
5997                 ID           ParticleSpawnerID
5998                 Vertical     bool
5999                 CollisionRm  bool
6000                 AttachedAOID AOID
6001                 AnimParams   TileAnim
6002                 Glow         uint8
6003                 AOCollision  bool
6004                 NodeParam0   Content
6005                 NodeParam2   uint8
6006                 NodeTile     uint8
6007         }))(obj)).Acc {
6008                 for local159 := range ((*(*(struct {
6009                         Amount         uint16
6010                         Duration       float32
6011                         Pos, Vel, Acc  [2][3]float32
6012                         ExpirationTime [2]float32 // in seconds.
6013                         Size           [2]float32
6014                         Collide        bool
6015
6016                         //mt:len32
6017                         Texture
6018
6019                         ID           ParticleSpawnerID
6020                         Vertical     bool
6021                         CollisionRm  bool
6022                         AttachedAOID AOID
6023                         AnimParams   TileAnim
6024                         Glow         uint8
6025                         AOCollision  bool
6026                         NodeParam0   Content
6027                         NodeParam2   uint8
6028                         NodeTile     uint8
6029                 }))(obj)).Acc)[local158] {
6030                         {
6031                                 x := (((*(*(struct {
6032                                         Amount         uint16
6033                                         Duration       float32
6034                                         Pos, Vel, Acc  [2][3]float32
6035                                         ExpirationTime [2]float32 // in seconds.
6036                                         Size           [2]float32
6037                                         Collide        bool
6038
6039                                         //mt:len32
6040                                         Texture
6041
6042                                         ID           ParticleSpawnerID
6043                                         Vertical     bool
6044                                         CollisionRm  bool
6045                                         AttachedAOID AOID
6046                                         AnimParams   TileAnim
6047                                         Glow         uint8
6048                                         AOCollision  bool
6049                                         NodeParam0   Content
6050                                         NodeParam2   uint8
6051                                         NodeTile     uint8
6052                                 }))(obj)).Acc)[local158])[local159]
6053                                 write32(w, math.Float32bits(x))
6054                         }
6055                 }
6056         }
6057         for local160 := range (*(*(struct {
6058                 Amount         uint16
6059                 Duration       float32
6060                 Pos, Vel, Acc  [2][3]float32
6061                 ExpirationTime [2]float32 // in seconds.
6062                 Size           [2]float32
6063                 Collide        bool
6064
6065                 //mt:len32
6066                 Texture
6067
6068                 ID           ParticleSpawnerID
6069                 Vertical     bool
6070                 CollisionRm  bool
6071                 AttachedAOID AOID
6072                 AnimParams   TileAnim
6073                 Glow         uint8
6074                 AOCollision  bool
6075                 NodeParam0   Content
6076                 NodeParam2   uint8
6077                 NodeTile     uint8
6078         }))(obj)).ExpirationTime {
6079                 {
6080                         x := ((*(*(struct {
6081                                 Amount         uint16
6082                                 Duration       float32
6083                                 Pos, Vel, Acc  [2][3]float32
6084                                 ExpirationTime [2]float32 // in seconds.
6085                                 Size           [2]float32
6086                                 Collide        bool
6087
6088                                 //mt:len32
6089                                 Texture
6090
6091                                 ID           ParticleSpawnerID
6092                                 Vertical     bool
6093                                 CollisionRm  bool
6094                                 AttachedAOID AOID
6095                                 AnimParams   TileAnim
6096                                 Glow         uint8
6097                                 AOCollision  bool
6098                                 NodeParam0   Content
6099                                 NodeParam2   uint8
6100                                 NodeTile     uint8
6101                         }))(obj)).ExpirationTime)[local160]
6102                         write32(w, math.Float32bits(x))
6103                 }
6104         }
6105         for local161 := range (*(*(struct {
6106                 Amount         uint16
6107                 Duration       float32
6108                 Pos, Vel, Acc  [2][3]float32
6109                 ExpirationTime [2]float32 // in seconds.
6110                 Size           [2]float32
6111                 Collide        bool
6112
6113                 //mt:len32
6114                 Texture
6115
6116                 ID           ParticleSpawnerID
6117                 Vertical     bool
6118                 CollisionRm  bool
6119                 AttachedAOID AOID
6120                 AnimParams   TileAnim
6121                 Glow         uint8
6122                 AOCollision  bool
6123                 NodeParam0   Content
6124                 NodeParam2   uint8
6125                 NodeTile     uint8
6126         }))(obj)).Size {
6127                 {
6128                         x := ((*(*(struct {
6129                                 Amount         uint16
6130                                 Duration       float32
6131                                 Pos, Vel, Acc  [2][3]float32
6132                                 ExpirationTime [2]float32 // in seconds.
6133                                 Size           [2]float32
6134                                 Collide        bool
6135
6136                                 //mt:len32
6137                                 Texture
6138
6139                                 ID           ParticleSpawnerID
6140                                 Vertical     bool
6141                                 CollisionRm  bool
6142                                 AttachedAOID AOID
6143                                 AnimParams   TileAnim
6144                                 Glow         uint8
6145                                 AOCollision  bool
6146                                 NodeParam0   Content
6147                                 NodeParam2   uint8
6148                                 NodeTile     uint8
6149                         }))(obj)).Size)[local161]
6150                         write32(w, math.Float32bits(x))
6151                 }
6152         }
6153         {
6154                 x := (*(*(struct {
6155                         Amount         uint16
6156                         Duration       float32
6157                         Pos, Vel, Acc  [2][3]float32
6158                         ExpirationTime [2]float32 // in seconds.
6159                         Size           [2]float32
6160                         Collide        bool
6161
6162                         //mt:len32
6163                         Texture
6164
6165                         ID           ParticleSpawnerID
6166                         Vertical     bool
6167                         CollisionRm  bool
6168                         AttachedAOID AOID
6169                         AnimParams   TileAnim
6170                         Glow         uint8
6171                         AOCollision  bool
6172                         NodeParam0   Content
6173                         NodeParam2   uint8
6174                         NodeTile     uint8
6175                 }))(obj)).Collide
6176                 if x {
6177                         write8(w, 1)
6178                 } else {
6179                         write8(w, 0)
6180                 }
6181         }
6182         if len(([]byte(*(*string)(&((*(*(struct {
6183                 Amount         uint16
6184                 Duration       float32
6185                 Pos, Vel, Acc  [2][3]float32
6186                 ExpirationTime [2]float32 // in seconds.
6187                 Size           [2]float32
6188                 Collide        bool
6189
6190                 //mt:len32
6191                 Texture
6192
6193                 ID           ParticleSpawnerID
6194                 Vertical     bool
6195                 CollisionRm  bool
6196                 AttachedAOID AOID
6197                 AnimParams   TileAnim
6198                 Glow         uint8
6199                 AOCollision  bool
6200                 NodeParam0   Content
6201                 NodeParam2   uint8
6202                 NodeTile     uint8
6203         }))(obj)).Texture))))) > math.MaxUint32 {
6204                 chk(ErrTooLong)
6205         }
6206         {
6207                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6208                         Amount         uint16
6209                         Duration       float32
6210                         Pos, Vel, Acc  [2][3]float32
6211                         ExpirationTime [2]float32 // in seconds.
6212                         Size           [2]float32
6213                         Collide        bool
6214
6215                         //mt:len32
6216                         Texture
6217
6218                         ID           ParticleSpawnerID
6219                         Vertical     bool
6220                         CollisionRm  bool
6221                         AttachedAOID AOID
6222                         AnimParams   TileAnim
6223                         Glow         uint8
6224                         AOCollision  bool
6225                         NodeParam0   Content
6226                         NodeParam2   uint8
6227                         NodeTile     uint8
6228                 }))(obj)).Texture))))))
6229                 write32(w, uint32(x))
6230         }
6231         {
6232                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6233                         Amount         uint16
6234                         Duration       float32
6235                         Pos, Vel, Acc  [2][3]float32
6236                         ExpirationTime [2]float32 // in seconds.
6237                         Size           [2]float32
6238                         Collide        bool
6239
6240                         //mt:len32
6241                         Texture
6242
6243                         ID           ParticleSpawnerID
6244                         Vertical     bool
6245                         CollisionRm  bool
6246                         AttachedAOID AOID
6247                         AnimParams   TileAnim
6248                         Glow         uint8
6249                         AOCollision  bool
6250                         NodeParam0   Content
6251                         NodeParam2   uint8
6252                         NodeTile     uint8
6253                 }))(obj)).Texture))))[:])
6254                 chk(err)
6255         }
6256         if err := pcall(func() {
6257                 ((*(*(struct {
6258                         Amount         uint16
6259                         Duration       float32
6260                         Pos, Vel, Acc  [2][3]float32
6261                         ExpirationTime [2]float32 // in seconds.
6262                         Size           [2]float32
6263                         Collide        bool
6264
6265                         //mt:len32
6266                         Texture
6267
6268                         ID           ParticleSpawnerID
6269                         Vertical     bool
6270                         CollisionRm  bool
6271                         AttachedAOID AOID
6272                         AnimParams   TileAnim
6273                         Glow         uint8
6274                         AOCollision  bool
6275                         NodeParam0   Content
6276                         NodeParam2   uint8
6277                         NodeTile     uint8
6278                 }))(obj)).ID).Serialize(w)
6279         }); err != nil {
6280                 if err == io.EOF {
6281                         chk(io.EOF)
6282                 }
6283                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
6284         }
6285         {
6286                 x := (*(*(struct {
6287                         Amount         uint16
6288                         Duration       float32
6289                         Pos, Vel, Acc  [2][3]float32
6290                         ExpirationTime [2]float32 // in seconds.
6291                         Size           [2]float32
6292                         Collide        bool
6293
6294                         //mt:len32
6295                         Texture
6296
6297                         ID           ParticleSpawnerID
6298                         Vertical     bool
6299                         CollisionRm  bool
6300                         AttachedAOID AOID
6301                         AnimParams   TileAnim
6302                         Glow         uint8
6303                         AOCollision  bool
6304                         NodeParam0   Content
6305                         NodeParam2   uint8
6306                         NodeTile     uint8
6307                 }))(obj)).Vertical
6308                 if x {
6309                         write8(w, 1)
6310                 } else {
6311                         write8(w, 0)
6312                 }
6313         }
6314         {
6315                 x := (*(*(struct {
6316                         Amount         uint16
6317                         Duration       float32
6318                         Pos, Vel, Acc  [2][3]float32
6319                         ExpirationTime [2]float32 // in seconds.
6320                         Size           [2]float32
6321                         Collide        bool
6322
6323                         //mt:len32
6324                         Texture
6325
6326                         ID           ParticleSpawnerID
6327                         Vertical     bool
6328                         CollisionRm  bool
6329                         AttachedAOID AOID
6330                         AnimParams   TileAnim
6331                         Glow         uint8
6332                         AOCollision  bool
6333                         NodeParam0   Content
6334                         NodeParam2   uint8
6335                         NodeTile     uint8
6336                 }))(obj)).CollisionRm
6337                 if x {
6338                         write8(w, 1)
6339                 } else {
6340                         write8(w, 0)
6341                 }
6342         }
6343         if err := pcall(func() {
6344                 ((*(*(struct {
6345                         Amount         uint16
6346                         Duration       float32
6347                         Pos, Vel, Acc  [2][3]float32
6348                         ExpirationTime [2]float32 // in seconds.
6349                         Size           [2]float32
6350                         Collide        bool
6351
6352                         //mt:len32
6353                         Texture
6354
6355                         ID           ParticleSpawnerID
6356                         Vertical     bool
6357                         CollisionRm  bool
6358                         AttachedAOID AOID
6359                         AnimParams   TileAnim
6360                         Glow         uint8
6361                         AOCollision  bool
6362                         NodeParam0   Content
6363                         NodeParam2   uint8
6364                         NodeTile     uint8
6365                 }))(obj)).AttachedAOID).Serialize(w)
6366         }); err != nil {
6367                 if err == io.EOF {
6368                         chk(io.EOF)
6369                 }
6370                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
6371         }
6372         if err := pcall(func() {
6373                 ((*(*(struct {
6374                         Amount         uint16
6375                         Duration       float32
6376                         Pos, Vel, Acc  [2][3]float32
6377                         ExpirationTime [2]float32 // in seconds.
6378                         Size           [2]float32
6379                         Collide        bool
6380
6381                         //mt:len32
6382                         Texture
6383
6384                         ID           ParticleSpawnerID
6385                         Vertical     bool
6386                         CollisionRm  bool
6387                         AttachedAOID AOID
6388                         AnimParams   TileAnim
6389                         Glow         uint8
6390                         AOCollision  bool
6391                         NodeParam0   Content
6392                         NodeParam2   uint8
6393                         NodeTile     uint8
6394                 }))(obj)).AnimParams).Serialize(w)
6395         }); err != nil {
6396                 if err == io.EOF {
6397                         chk(io.EOF)
6398                 }
6399                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
6400         }
6401         {
6402                 x := (*(*(struct {
6403                         Amount         uint16
6404                         Duration       float32
6405                         Pos, Vel, Acc  [2][3]float32
6406                         ExpirationTime [2]float32 // in seconds.
6407                         Size           [2]float32
6408                         Collide        bool
6409
6410                         //mt:len32
6411                         Texture
6412
6413                         ID           ParticleSpawnerID
6414                         Vertical     bool
6415                         CollisionRm  bool
6416                         AttachedAOID AOID
6417                         AnimParams   TileAnim
6418                         Glow         uint8
6419                         AOCollision  bool
6420                         NodeParam0   Content
6421                         NodeParam2   uint8
6422                         NodeTile     uint8
6423                 }))(obj)).Glow
6424                 write8(w, uint8(x))
6425         }
6426         {
6427                 x := (*(*(struct {
6428                         Amount         uint16
6429                         Duration       float32
6430                         Pos, Vel, Acc  [2][3]float32
6431                         ExpirationTime [2]float32 // in seconds.
6432                         Size           [2]float32
6433                         Collide        bool
6434
6435                         //mt:len32
6436                         Texture
6437
6438                         ID           ParticleSpawnerID
6439                         Vertical     bool
6440                         CollisionRm  bool
6441                         AttachedAOID AOID
6442                         AnimParams   TileAnim
6443                         Glow         uint8
6444                         AOCollision  bool
6445                         NodeParam0   Content
6446                         NodeParam2   uint8
6447                         NodeTile     uint8
6448                 }))(obj)).AOCollision
6449                 if x {
6450                         write8(w, 1)
6451                 } else {
6452                         write8(w, 0)
6453                 }
6454         }
6455         if err := pcall(func() {
6456                 ((*(*(struct {
6457                         Amount         uint16
6458                         Duration       float32
6459                         Pos, Vel, Acc  [2][3]float32
6460                         ExpirationTime [2]float32 // in seconds.
6461                         Size           [2]float32
6462                         Collide        bool
6463
6464                         //mt:len32
6465                         Texture
6466
6467                         ID           ParticleSpawnerID
6468                         Vertical     bool
6469                         CollisionRm  bool
6470                         AttachedAOID AOID
6471                         AnimParams   TileAnim
6472                         Glow         uint8
6473                         AOCollision  bool
6474                         NodeParam0   Content
6475                         NodeParam2   uint8
6476                         NodeTile     uint8
6477                 }))(obj)).NodeParam0).Serialize(w)
6478         }); err != nil {
6479                 if err == io.EOF {
6480                         chk(io.EOF)
6481                 }
6482                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
6483         }
6484         {
6485                 x := (*(*(struct {
6486                         Amount         uint16
6487                         Duration       float32
6488                         Pos, Vel, Acc  [2][3]float32
6489                         ExpirationTime [2]float32 // in seconds.
6490                         Size           [2]float32
6491                         Collide        bool
6492
6493                         //mt:len32
6494                         Texture
6495
6496                         ID           ParticleSpawnerID
6497                         Vertical     bool
6498                         CollisionRm  bool
6499                         AttachedAOID AOID
6500                         AnimParams   TileAnim
6501                         Glow         uint8
6502                         AOCollision  bool
6503                         NodeParam0   Content
6504                         NodeParam2   uint8
6505                         NodeTile     uint8
6506                 }))(obj)).NodeParam2
6507                 write8(w, uint8(x))
6508         }
6509         {
6510                 x := (*(*(struct {
6511                         Amount         uint16
6512                         Duration       float32
6513                         Pos, Vel, Acc  [2][3]float32
6514                         ExpirationTime [2]float32 // in seconds.
6515                         Size           [2]float32
6516                         Collide        bool
6517
6518                         //mt:len32
6519                         Texture
6520
6521                         ID           ParticleSpawnerID
6522                         Vertical     bool
6523                         CollisionRm  bool
6524                         AttachedAOID AOID
6525                         AnimParams   TileAnim
6526                         Glow         uint8
6527                         AOCollision  bool
6528                         NodeParam0   Content
6529                         NodeParam2   uint8
6530                         NodeTile     uint8
6531                 }))(obj)).NodeTile
6532                 write8(w, uint8(x))
6533         }
6534 }
6535
6536 func (obj *ToCltAddParticleSpawner) Deserialize(r io.Reader) {
6537         {
6538                 p := &(*(*(struct {
6539                         Amount         uint16
6540                         Duration       float32
6541                         Pos, Vel, Acc  [2][3]float32
6542                         ExpirationTime [2]float32 // in seconds.
6543                         Size           [2]float32
6544                         Collide        bool
6545
6546                         //mt:len32
6547                         Texture
6548
6549                         ID           ParticleSpawnerID
6550                         Vertical     bool
6551                         CollisionRm  bool
6552                         AttachedAOID AOID
6553                         AnimParams   TileAnim
6554                         Glow         uint8
6555                         AOCollision  bool
6556                         NodeParam0   Content
6557                         NodeParam2   uint8
6558                         NodeTile     uint8
6559                 }))(obj)).Amount
6560                 *p = read16(r)
6561         }
6562         {
6563                 p := &(*(*(struct {
6564                         Amount         uint16
6565                         Duration       float32
6566                         Pos, Vel, Acc  [2][3]float32
6567                         ExpirationTime [2]float32 // in seconds.
6568                         Size           [2]float32
6569                         Collide        bool
6570
6571                         //mt:len32
6572                         Texture
6573
6574                         ID           ParticleSpawnerID
6575                         Vertical     bool
6576                         CollisionRm  bool
6577                         AttachedAOID AOID
6578                         AnimParams   TileAnim
6579                         Glow         uint8
6580                         AOCollision  bool
6581                         NodeParam0   Content
6582                         NodeParam2   uint8
6583                         NodeTile     uint8
6584                 }))(obj)).Duration
6585                 *p = math.Float32frombits(read32(r))
6586         }
6587         for local162 := range (*(*(struct {
6588                 Amount         uint16
6589                 Duration       float32
6590                 Pos, Vel, Acc  [2][3]float32
6591                 ExpirationTime [2]float32 // in seconds.
6592                 Size           [2]float32
6593                 Collide        bool
6594
6595                 //mt:len32
6596                 Texture
6597
6598                 ID           ParticleSpawnerID
6599                 Vertical     bool
6600                 CollisionRm  bool
6601                 AttachedAOID AOID
6602                 AnimParams   TileAnim
6603                 Glow         uint8
6604                 AOCollision  bool
6605                 NodeParam0   Content
6606                 NodeParam2   uint8
6607                 NodeTile     uint8
6608         }))(obj)).Pos {
6609                 for local163 := range ((*(*(struct {
6610                         Amount         uint16
6611                         Duration       float32
6612                         Pos, Vel, Acc  [2][3]float32
6613                         ExpirationTime [2]float32 // in seconds.
6614                         Size           [2]float32
6615                         Collide        bool
6616
6617                         //mt:len32
6618                         Texture
6619
6620                         ID           ParticleSpawnerID
6621                         Vertical     bool
6622                         CollisionRm  bool
6623                         AttachedAOID AOID
6624                         AnimParams   TileAnim
6625                         Glow         uint8
6626                         AOCollision  bool
6627                         NodeParam0   Content
6628                         NodeParam2   uint8
6629                         NodeTile     uint8
6630                 }))(obj)).Pos)[local162] {
6631                         {
6632                                 p := &(((*(*(struct {
6633                                         Amount         uint16
6634                                         Duration       float32
6635                                         Pos, Vel, Acc  [2][3]float32
6636                                         ExpirationTime [2]float32 // in seconds.
6637                                         Size           [2]float32
6638                                         Collide        bool
6639
6640                                         //mt:len32
6641                                         Texture
6642
6643                                         ID           ParticleSpawnerID
6644                                         Vertical     bool
6645                                         CollisionRm  bool
6646                                         AttachedAOID AOID
6647                                         AnimParams   TileAnim
6648                                         Glow         uint8
6649                                         AOCollision  bool
6650                                         NodeParam0   Content
6651                                         NodeParam2   uint8
6652                                         NodeTile     uint8
6653                                 }))(obj)).Pos)[local162])[local163]
6654                                 *p = math.Float32frombits(read32(r))
6655                         }
6656                 }
6657         }
6658         for local164 := range (*(*(struct {
6659                 Amount         uint16
6660                 Duration       float32
6661                 Pos, Vel, Acc  [2][3]float32
6662                 ExpirationTime [2]float32 // in seconds.
6663                 Size           [2]float32
6664                 Collide        bool
6665
6666                 //mt:len32
6667                 Texture
6668
6669                 ID           ParticleSpawnerID
6670                 Vertical     bool
6671                 CollisionRm  bool
6672                 AttachedAOID AOID
6673                 AnimParams   TileAnim
6674                 Glow         uint8
6675                 AOCollision  bool
6676                 NodeParam0   Content
6677                 NodeParam2   uint8
6678                 NodeTile     uint8
6679         }))(obj)).Vel {
6680                 for local165 := range ((*(*(struct {
6681                         Amount         uint16
6682                         Duration       float32
6683                         Pos, Vel, Acc  [2][3]float32
6684                         ExpirationTime [2]float32 // in seconds.
6685                         Size           [2]float32
6686                         Collide        bool
6687
6688                         //mt:len32
6689                         Texture
6690
6691                         ID           ParticleSpawnerID
6692                         Vertical     bool
6693                         CollisionRm  bool
6694                         AttachedAOID AOID
6695                         AnimParams   TileAnim
6696                         Glow         uint8
6697                         AOCollision  bool
6698                         NodeParam0   Content
6699                         NodeParam2   uint8
6700                         NodeTile     uint8
6701                 }))(obj)).Vel)[local164] {
6702                         {
6703                                 p := &(((*(*(struct {
6704                                         Amount         uint16
6705                                         Duration       float32
6706                                         Pos, Vel, Acc  [2][3]float32
6707                                         ExpirationTime [2]float32 // in seconds.
6708                                         Size           [2]float32
6709                                         Collide        bool
6710
6711                                         //mt:len32
6712                                         Texture
6713
6714                                         ID           ParticleSpawnerID
6715                                         Vertical     bool
6716                                         CollisionRm  bool
6717                                         AttachedAOID AOID
6718                                         AnimParams   TileAnim
6719                                         Glow         uint8
6720                                         AOCollision  bool
6721                                         NodeParam0   Content
6722                                         NodeParam2   uint8
6723                                         NodeTile     uint8
6724                                 }))(obj)).Vel)[local164])[local165]
6725                                 *p = math.Float32frombits(read32(r))
6726                         }
6727                 }
6728         }
6729         for local166 := range (*(*(struct {
6730                 Amount         uint16
6731                 Duration       float32
6732                 Pos, Vel, Acc  [2][3]float32
6733                 ExpirationTime [2]float32 // in seconds.
6734                 Size           [2]float32
6735                 Collide        bool
6736
6737                 //mt:len32
6738                 Texture
6739
6740                 ID           ParticleSpawnerID
6741                 Vertical     bool
6742                 CollisionRm  bool
6743                 AttachedAOID AOID
6744                 AnimParams   TileAnim
6745                 Glow         uint8
6746                 AOCollision  bool
6747                 NodeParam0   Content
6748                 NodeParam2   uint8
6749                 NodeTile     uint8
6750         }))(obj)).Acc {
6751                 for local167 := range ((*(*(struct {
6752                         Amount         uint16
6753                         Duration       float32
6754                         Pos, Vel, Acc  [2][3]float32
6755                         ExpirationTime [2]float32 // in seconds.
6756                         Size           [2]float32
6757                         Collide        bool
6758
6759                         //mt:len32
6760                         Texture
6761
6762                         ID           ParticleSpawnerID
6763                         Vertical     bool
6764                         CollisionRm  bool
6765                         AttachedAOID AOID
6766                         AnimParams   TileAnim
6767                         Glow         uint8
6768                         AOCollision  bool
6769                         NodeParam0   Content
6770                         NodeParam2   uint8
6771                         NodeTile     uint8
6772                 }))(obj)).Acc)[local166] {
6773                         {
6774                                 p := &(((*(*(struct {
6775                                         Amount         uint16
6776                                         Duration       float32
6777                                         Pos, Vel, Acc  [2][3]float32
6778                                         ExpirationTime [2]float32 // in seconds.
6779                                         Size           [2]float32
6780                                         Collide        bool
6781
6782                                         //mt:len32
6783                                         Texture
6784
6785                                         ID           ParticleSpawnerID
6786                                         Vertical     bool
6787                                         CollisionRm  bool
6788                                         AttachedAOID AOID
6789                                         AnimParams   TileAnim
6790                                         Glow         uint8
6791                                         AOCollision  bool
6792                                         NodeParam0   Content
6793                                         NodeParam2   uint8
6794                                         NodeTile     uint8
6795                                 }))(obj)).Acc)[local166])[local167]
6796                                 *p = math.Float32frombits(read32(r))
6797                         }
6798                 }
6799         }
6800         for local168 := range (*(*(struct {
6801                 Amount         uint16
6802                 Duration       float32
6803                 Pos, Vel, Acc  [2][3]float32
6804                 ExpirationTime [2]float32 // in seconds.
6805                 Size           [2]float32
6806                 Collide        bool
6807
6808                 //mt:len32
6809                 Texture
6810
6811                 ID           ParticleSpawnerID
6812                 Vertical     bool
6813                 CollisionRm  bool
6814                 AttachedAOID AOID
6815                 AnimParams   TileAnim
6816                 Glow         uint8
6817                 AOCollision  bool
6818                 NodeParam0   Content
6819                 NodeParam2   uint8
6820                 NodeTile     uint8
6821         }))(obj)).ExpirationTime {
6822                 {
6823                         p := &((*(*(struct {
6824                                 Amount         uint16
6825                                 Duration       float32
6826                                 Pos, Vel, Acc  [2][3]float32
6827                                 ExpirationTime [2]float32 // in seconds.
6828                                 Size           [2]float32
6829                                 Collide        bool
6830
6831                                 //mt:len32
6832                                 Texture
6833
6834                                 ID           ParticleSpawnerID
6835                                 Vertical     bool
6836                                 CollisionRm  bool
6837                                 AttachedAOID AOID
6838                                 AnimParams   TileAnim
6839                                 Glow         uint8
6840                                 AOCollision  bool
6841                                 NodeParam0   Content
6842                                 NodeParam2   uint8
6843                                 NodeTile     uint8
6844                         }))(obj)).ExpirationTime)[local168]
6845                         *p = math.Float32frombits(read32(r))
6846                 }
6847         }
6848         for local169 := range (*(*(struct {
6849                 Amount         uint16
6850                 Duration       float32
6851                 Pos, Vel, Acc  [2][3]float32
6852                 ExpirationTime [2]float32 // in seconds.
6853                 Size           [2]float32
6854                 Collide        bool
6855
6856                 //mt:len32
6857                 Texture
6858
6859                 ID           ParticleSpawnerID
6860                 Vertical     bool
6861                 CollisionRm  bool
6862                 AttachedAOID AOID
6863                 AnimParams   TileAnim
6864                 Glow         uint8
6865                 AOCollision  bool
6866                 NodeParam0   Content
6867                 NodeParam2   uint8
6868                 NodeTile     uint8
6869         }))(obj)).Size {
6870                 {
6871                         p := &((*(*(struct {
6872                                 Amount         uint16
6873                                 Duration       float32
6874                                 Pos, Vel, Acc  [2][3]float32
6875                                 ExpirationTime [2]float32 // in seconds.
6876                                 Size           [2]float32
6877                                 Collide        bool
6878
6879                                 //mt:len32
6880                                 Texture
6881
6882                                 ID           ParticleSpawnerID
6883                                 Vertical     bool
6884                                 CollisionRm  bool
6885                                 AttachedAOID AOID
6886                                 AnimParams   TileAnim
6887                                 Glow         uint8
6888                                 AOCollision  bool
6889                                 NodeParam0   Content
6890                                 NodeParam2   uint8
6891                                 NodeTile     uint8
6892                         }))(obj)).Size)[local169]
6893                         *p = math.Float32frombits(read32(r))
6894                 }
6895         }
6896         {
6897                 p := &(*(*(struct {
6898                         Amount         uint16
6899                         Duration       float32
6900                         Pos, Vel, Acc  [2][3]float32
6901                         ExpirationTime [2]float32 // in seconds.
6902                         Size           [2]float32
6903                         Collide        bool
6904
6905                         //mt:len32
6906                         Texture
6907
6908                         ID           ParticleSpawnerID
6909                         Vertical     bool
6910                         CollisionRm  bool
6911                         AttachedAOID AOID
6912                         AnimParams   TileAnim
6913                         Glow         uint8
6914                         AOCollision  bool
6915                         NodeParam0   Content
6916                         NodeParam2   uint8
6917                         NodeTile     uint8
6918                 }))(obj)).Collide
6919                 switch n := read8(r); n {
6920                 case 0:
6921                         *p = false
6922                 case 1:
6923                         *p = true
6924                 default:
6925                         chk(fmt.Errorf("invalid bool: %d", n))
6926                 }
6927         }
6928         var local170 []uint8
6929         var local171 uint32
6930         {
6931                 p := &local171
6932                 *p = read32(r)
6933         }
6934         (local170) = make([]uint8, local171)
6935         {
6936                 _, err := io.ReadFull(r, (local170)[:])
6937                 chk(err)
6938         }
6939         (*(*string)(&((*(*(struct {
6940                 Amount         uint16
6941                 Duration       float32
6942                 Pos, Vel, Acc  [2][3]float32
6943                 ExpirationTime [2]float32 // in seconds.
6944                 Size           [2]float32
6945                 Collide        bool
6946
6947                 //mt:len32
6948                 Texture
6949
6950                 ID           ParticleSpawnerID
6951                 Vertical     bool
6952                 CollisionRm  bool
6953                 AttachedAOID AOID
6954                 AnimParams   TileAnim
6955                 Glow         uint8
6956                 AOCollision  bool
6957                 NodeParam0   Content
6958                 NodeParam2   uint8
6959                 NodeTile     uint8
6960         }))(obj)).Texture))) = string(local170)
6961         if err := pcall(func() {
6962                 ((*(*(struct {
6963                         Amount         uint16
6964                         Duration       float32
6965                         Pos, Vel, Acc  [2][3]float32
6966                         ExpirationTime [2]float32 // in seconds.
6967                         Size           [2]float32
6968                         Collide        bool
6969
6970                         //mt:len32
6971                         Texture
6972
6973                         ID           ParticleSpawnerID
6974                         Vertical     bool
6975                         CollisionRm  bool
6976                         AttachedAOID AOID
6977                         AnimParams   TileAnim
6978                         Glow         uint8
6979                         AOCollision  bool
6980                         NodeParam0   Content
6981                         NodeParam2   uint8
6982                         NodeTile     uint8
6983                 }))(obj)).ID).Deserialize(r)
6984         }); err != nil {
6985                 if err == io.EOF {
6986                         chk(io.EOF)
6987                 }
6988                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
6989         }
6990         {
6991                 p := &(*(*(struct {
6992                         Amount         uint16
6993                         Duration       float32
6994                         Pos, Vel, Acc  [2][3]float32
6995                         ExpirationTime [2]float32 // in seconds.
6996                         Size           [2]float32
6997                         Collide        bool
6998
6999                         //mt:len32
7000                         Texture
7001
7002                         ID           ParticleSpawnerID
7003                         Vertical     bool
7004                         CollisionRm  bool
7005                         AttachedAOID AOID
7006                         AnimParams   TileAnim
7007                         Glow         uint8
7008                         AOCollision  bool
7009                         NodeParam0   Content
7010                         NodeParam2   uint8
7011                         NodeTile     uint8
7012                 }))(obj)).Vertical
7013                 switch n := read8(r); n {
7014                 case 0:
7015                         *p = false
7016                 case 1:
7017                         *p = true
7018                 default:
7019                         chk(fmt.Errorf("invalid bool: %d", n))
7020                 }
7021         }
7022         {
7023                 p := &(*(*(struct {
7024                         Amount         uint16
7025                         Duration       float32
7026                         Pos, Vel, Acc  [2][3]float32
7027                         ExpirationTime [2]float32 // in seconds.
7028                         Size           [2]float32
7029                         Collide        bool
7030
7031                         //mt:len32
7032                         Texture
7033
7034                         ID           ParticleSpawnerID
7035                         Vertical     bool
7036                         CollisionRm  bool
7037                         AttachedAOID AOID
7038                         AnimParams   TileAnim
7039                         Glow         uint8
7040                         AOCollision  bool
7041                         NodeParam0   Content
7042                         NodeParam2   uint8
7043                         NodeTile     uint8
7044                 }))(obj)).CollisionRm
7045                 switch n := read8(r); n {
7046                 case 0:
7047                         *p = false
7048                 case 1:
7049                         *p = true
7050                 default:
7051                         chk(fmt.Errorf("invalid bool: %d", n))
7052                 }
7053         }
7054         if err := pcall(func() {
7055                 ((*(*(struct {
7056                         Amount         uint16
7057                         Duration       float32
7058                         Pos, Vel, Acc  [2][3]float32
7059                         ExpirationTime [2]float32 // in seconds.
7060                         Size           [2]float32
7061                         Collide        bool
7062
7063                         //mt:len32
7064                         Texture
7065
7066                         ID           ParticleSpawnerID
7067                         Vertical     bool
7068                         CollisionRm  bool
7069                         AttachedAOID AOID
7070                         AnimParams   TileAnim
7071                         Glow         uint8
7072                         AOCollision  bool
7073                         NodeParam0   Content
7074                         NodeParam2   uint8
7075                         NodeTile     uint8
7076                 }))(obj)).AttachedAOID).Deserialize(r)
7077         }); err != nil {
7078                 if err == io.EOF {
7079                         chk(io.EOF)
7080                 }
7081                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
7082         }
7083         if err := pcall(func() {
7084                 ((*(*(struct {
7085                         Amount         uint16
7086                         Duration       float32
7087                         Pos, Vel, Acc  [2][3]float32
7088                         ExpirationTime [2]float32 // in seconds.
7089                         Size           [2]float32
7090                         Collide        bool
7091
7092                         //mt:len32
7093                         Texture
7094
7095                         ID           ParticleSpawnerID
7096                         Vertical     bool
7097                         CollisionRm  bool
7098                         AttachedAOID AOID
7099                         AnimParams   TileAnim
7100                         Glow         uint8
7101                         AOCollision  bool
7102                         NodeParam0   Content
7103                         NodeParam2   uint8
7104                         NodeTile     uint8
7105                 }))(obj)).AnimParams).Deserialize(r)
7106         }); err != nil {
7107                 if err == io.EOF {
7108                         chk(io.EOF)
7109                 }
7110                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
7111         }
7112         {
7113                 p := &(*(*(struct {
7114                         Amount         uint16
7115                         Duration       float32
7116                         Pos, Vel, Acc  [2][3]float32
7117                         ExpirationTime [2]float32 // in seconds.
7118                         Size           [2]float32
7119                         Collide        bool
7120
7121                         //mt:len32
7122                         Texture
7123
7124                         ID           ParticleSpawnerID
7125                         Vertical     bool
7126                         CollisionRm  bool
7127                         AttachedAOID AOID
7128                         AnimParams   TileAnim
7129                         Glow         uint8
7130                         AOCollision  bool
7131                         NodeParam0   Content
7132                         NodeParam2   uint8
7133                         NodeTile     uint8
7134                 }))(obj)).Glow
7135                 *p = read8(r)
7136         }
7137         {
7138                 p := &(*(*(struct {
7139                         Amount         uint16
7140                         Duration       float32
7141                         Pos, Vel, Acc  [2][3]float32
7142                         ExpirationTime [2]float32 // in seconds.
7143                         Size           [2]float32
7144                         Collide        bool
7145
7146                         //mt:len32
7147                         Texture
7148
7149                         ID           ParticleSpawnerID
7150                         Vertical     bool
7151                         CollisionRm  bool
7152                         AttachedAOID AOID
7153                         AnimParams   TileAnim
7154                         Glow         uint8
7155                         AOCollision  bool
7156                         NodeParam0   Content
7157                         NodeParam2   uint8
7158                         NodeTile     uint8
7159                 }))(obj)).AOCollision
7160                 switch n := read8(r); n {
7161                 case 0:
7162                         *p = false
7163                 case 1:
7164                         *p = true
7165                 default:
7166                         chk(fmt.Errorf("invalid bool: %d", n))
7167                 }
7168         }
7169         if err := pcall(func() {
7170                 ((*(*(struct {
7171                         Amount         uint16
7172                         Duration       float32
7173                         Pos, Vel, Acc  [2][3]float32
7174                         ExpirationTime [2]float32 // in seconds.
7175                         Size           [2]float32
7176                         Collide        bool
7177
7178                         //mt:len32
7179                         Texture
7180
7181                         ID           ParticleSpawnerID
7182                         Vertical     bool
7183                         CollisionRm  bool
7184                         AttachedAOID AOID
7185                         AnimParams   TileAnim
7186                         Glow         uint8
7187                         AOCollision  bool
7188                         NodeParam0   Content
7189                         NodeParam2   uint8
7190                         NodeTile     uint8
7191                 }))(obj)).NodeParam0).Deserialize(r)
7192         }); err != nil {
7193                 if err == io.EOF {
7194                         chk(io.EOF)
7195                 }
7196                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
7197         }
7198         {
7199                 p := &(*(*(struct {
7200                         Amount         uint16
7201                         Duration       float32
7202                         Pos, Vel, Acc  [2][3]float32
7203                         ExpirationTime [2]float32 // in seconds.
7204                         Size           [2]float32
7205                         Collide        bool
7206
7207                         //mt:len32
7208                         Texture
7209
7210                         ID           ParticleSpawnerID
7211                         Vertical     bool
7212                         CollisionRm  bool
7213                         AttachedAOID AOID
7214                         AnimParams   TileAnim
7215                         Glow         uint8
7216                         AOCollision  bool
7217                         NodeParam0   Content
7218                         NodeParam2   uint8
7219                         NodeTile     uint8
7220                 }))(obj)).NodeParam2
7221                 *p = read8(r)
7222         }
7223         {
7224                 p := &(*(*(struct {
7225                         Amount         uint16
7226                         Duration       float32
7227                         Pos, Vel, Acc  [2][3]float32
7228                         ExpirationTime [2]float32 // in seconds.
7229                         Size           [2]float32
7230                         Collide        bool
7231
7232                         //mt:len32
7233                         Texture
7234
7235                         ID           ParticleSpawnerID
7236                         Vertical     bool
7237                         CollisionRm  bool
7238                         AttachedAOID AOID
7239                         AnimParams   TileAnim
7240                         Glow         uint8
7241                         AOCollision  bool
7242                         NodeParam0   Content
7243                         NodeParam2   uint8
7244                         NodeTile     uint8
7245                 }))(obj)).NodeTile
7246                 *p = read8(r)
7247         }
7248 }
7249
7250 func (obj *ToCltAddHUD) Serialize(w io.Writer) {
7251         if err := pcall(func() {
7252                 ((*(*(struct {
7253                         ID HUDID
7254                         HUD
7255                 }))(obj)).ID).Serialize(w)
7256         }); err != nil {
7257                 if err == io.EOF {
7258                         chk(io.EOF)
7259                 }
7260                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7261         }
7262         if err := pcall(func() {
7263                 ((*(*(struct {
7264                         ID HUDID
7265                         HUD
7266                 }))(obj)).HUD).Serialize(w)
7267         }); err != nil {
7268                 if err == io.EOF {
7269                         chk(io.EOF)
7270                 }
7271                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUD", err))
7272         }
7273 }
7274
7275 func (obj *ToCltAddHUD) Deserialize(r io.Reader) {
7276         if err := pcall(func() {
7277                 ((*(*(struct {
7278                         ID HUDID
7279                         HUD
7280                 }))(obj)).ID).Deserialize(r)
7281         }); err != nil {
7282                 if err == io.EOF {
7283                         chk(io.EOF)
7284                 }
7285                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7286         }
7287         if err := pcall(func() {
7288                 ((*(*(struct {
7289                         ID HUDID
7290                         HUD
7291                 }))(obj)).HUD).Deserialize(r)
7292         }); err != nil {
7293                 if err == io.EOF {
7294                         chk(io.EOF)
7295                 }
7296                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUD", err))
7297         }
7298 }
7299
7300 func (obj *ToCltRmHUD) Serialize(w io.Writer) {
7301         if err := pcall(func() {
7302                 ((*(*(struct {
7303                         ID HUDID
7304                 }))(obj)).ID).Serialize(w)
7305         }); err != nil {
7306                 if err == io.EOF {
7307                         chk(io.EOF)
7308                 }
7309                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7310         }
7311 }
7312
7313 func (obj *ToCltRmHUD) Deserialize(r io.Reader) {
7314         if err := pcall(func() {
7315                 ((*(*(struct {
7316                         ID HUDID
7317                 }))(obj)).ID).Deserialize(r)
7318         }); err != nil {
7319                 if err == io.EOF {
7320                         chk(io.EOF)
7321                 }
7322                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7323         }
7324 }
7325
7326 func (obj *ToCltChangeHUD) Serialize(w io.Writer) {
7327         if err := pcall(func() {
7328                 ((*(*(struct {
7329                         ID HUDID
7330
7331                         Field HUDField
7332
7333                         //mt:if %s.Field == HUDPos
7334                         Pos [2]float32
7335
7336                         //mt:if %s.Field == HUDName
7337                         Name string
7338
7339                         //mt:if %s.Field == HUDScale
7340                         Scale [2]float32
7341
7342                         //mt:if %s.Field == HUDText
7343                         Text string
7344
7345                         //mt:if %s.Field == HUDNumber
7346                         Number uint32
7347
7348                         //mt:if %s.Field == HUDItem
7349                         Item uint32
7350
7351                         //mt:if %s.Field == HUDDir
7352                         Dir uint32
7353
7354                         //mt:if %s.Field == HUDAlign
7355                         Align [2]float32
7356
7357                         //mt:if %s.Field == HUDOffset
7358                         Offset [2]float32
7359
7360                         //mt:if %s.Field == HUDWorldPos
7361                         WorldPos Pos
7362
7363                         //mt:if %s.Field == HUDSize
7364                         Size [2]int32
7365
7366                         //mt:if %s.Field == HUDZIndex
7367                         ZIndex int32
7368
7369                         //mt:if %s.Field == HUDText2
7370                         Text2 string
7371
7372                         //mt:if %s.Field == HUDStyle
7373                         Style HUDStyleFlags
7374                 }))(obj)).ID).Serialize(w)
7375         }); err != nil {
7376                 if err == io.EOF {
7377                         chk(io.EOF)
7378                 }
7379                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7380         }
7381         if err := pcall(func() {
7382                 ((*(*(struct {
7383                         ID HUDID
7384
7385                         Field HUDField
7386
7387                         //mt:if %s.Field == HUDPos
7388                         Pos [2]float32
7389
7390                         //mt:if %s.Field == HUDName
7391                         Name string
7392
7393                         //mt:if %s.Field == HUDScale
7394                         Scale [2]float32
7395
7396                         //mt:if %s.Field == HUDText
7397                         Text string
7398
7399                         //mt:if %s.Field == HUDNumber
7400                         Number uint32
7401
7402                         //mt:if %s.Field == HUDItem
7403                         Item uint32
7404
7405                         //mt:if %s.Field == HUDDir
7406                         Dir uint32
7407
7408                         //mt:if %s.Field == HUDAlign
7409                         Align [2]float32
7410
7411                         //mt:if %s.Field == HUDOffset
7412                         Offset [2]float32
7413
7414                         //mt:if %s.Field == HUDWorldPos
7415                         WorldPos Pos
7416
7417                         //mt:if %s.Field == HUDSize
7418                         Size [2]int32
7419
7420                         //mt:if %s.Field == HUDZIndex
7421                         ZIndex int32
7422
7423                         //mt:if %s.Field == HUDText2
7424                         Text2 string
7425
7426                         //mt:if %s.Field == HUDStyle
7427                         Style HUDStyleFlags
7428                 }))(obj)).Field).Serialize(w)
7429         }); err != nil {
7430                 if err == io.EOF {
7431                         chk(io.EOF)
7432                 }
7433                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDField", err))
7434         }
7435         if !((*(*(struct {
7436                 ID HUDID
7437
7438                 Field HUDField
7439
7440                 //mt:if %s.Field == HUDPos
7441                 Pos [2]float32
7442
7443                 //mt:if %s.Field == HUDName
7444                 Name string
7445
7446                 //mt:if %s.Field == HUDScale
7447                 Scale [2]float32
7448
7449                 //mt:if %s.Field == HUDText
7450                 Text string
7451
7452                 //mt:if %s.Field == HUDNumber
7453                 Number uint32
7454
7455                 //mt:if %s.Field == HUDItem
7456                 Item uint32
7457
7458                 //mt:if %s.Field == HUDDir
7459                 Dir uint32
7460
7461                 //mt:if %s.Field == HUDAlign
7462                 Align [2]float32
7463
7464                 //mt:if %s.Field == HUDOffset
7465                 Offset [2]float32
7466
7467                 //mt:if %s.Field == HUDWorldPos
7468                 WorldPos Pos
7469
7470                 //mt:if %s.Field == HUDSize
7471                 Size [2]int32
7472
7473                 //mt:if %s.Field == HUDZIndex
7474                 ZIndex int32
7475
7476                 //mt:if %s.Field == HUDText2
7477                 Text2 string
7478
7479                 //mt:if %s.Field == HUDStyle
7480                 Style HUDStyleFlags
7481         }))(obj)).Field < hudMax) {
7482                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7483         }
7484         if (*(*(struct {
7485                 ID HUDID
7486
7487                 Field HUDField
7488
7489                 //mt:if %s.Field == HUDPos
7490                 Pos [2]float32
7491
7492                 //mt:if %s.Field == HUDName
7493                 Name string
7494
7495                 //mt:if %s.Field == HUDScale
7496                 Scale [2]float32
7497
7498                 //mt:if %s.Field == HUDText
7499                 Text string
7500
7501                 //mt:if %s.Field == HUDNumber
7502                 Number uint32
7503
7504                 //mt:if %s.Field == HUDItem
7505                 Item uint32
7506
7507                 //mt:if %s.Field == HUDDir
7508                 Dir uint32
7509
7510                 //mt:if %s.Field == HUDAlign
7511                 Align [2]float32
7512
7513                 //mt:if %s.Field == HUDOffset
7514                 Offset [2]float32
7515
7516                 //mt:if %s.Field == HUDWorldPos
7517                 WorldPos Pos
7518
7519                 //mt:if %s.Field == HUDSize
7520                 Size [2]int32
7521
7522                 //mt:if %s.Field == HUDZIndex
7523                 ZIndex int32
7524
7525                 //mt:if %s.Field == HUDText2
7526                 Text2 string
7527
7528                 //mt:if %s.Field == HUDStyle
7529                 Style HUDStyleFlags
7530         }))(obj)).Field == HUDPos {
7531                 for local172 := range (*(*(struct {
7532                         ID HUDID
7533
7534                         Field HUDField
7535
7536                         //mt:if %s.Field == HUDPos
7537                         Pos [2]float32
7538
7539                         //mt:if %s.Field == HUDName
7540                         Name string
7541
7542                         //mt:if %s.Field == HUDScale
7543                         Scale [2]float32
7544
7545                         //mt:if %s.Field == HUDText
7546                         Text string
7547
7548                         //mt:if %s.Field == HUDNumber
7549                         Number uint32
7550
7551                         //mt:if %s.Field == HUDItem
7552                         Item uint32
7553
7554                         //mt:if %s.Field == HUDDir
7555                         Dir uint32
7556
7557                         //mt:if %s.Field == HUDAlign
7558                         Align [2]float32
7559
7560                         //mt:if %s.Field == HUDOffset
7561                         Offset [2]float32
7562
7563                         //mt:if %s.Field == HUDWorldPos
7564                         WorldPos Pos
7565
7566                         //mt:if %s.Field == HUDSize
7567                         Size [2]int32
7568
7569                         //mt:if %s.Field == HUDZIndex
7570                         ZIndex int32
7571
7572                         //mt:if %s.Field == HUDText2
7573                         Text2 string
7574
7575                         //mt:if %s.Field == HUDStyle
7576                         Style HUDStyleFlags
7577                 }))(obj)).Pos {
7578                         {
7579                                 x := ((*(*(struct {
7580                                         ID HUDID
7581
7582                                         Field HUDField
7583
7584                                         //mt:if %s.Field == HUDPos
7585                                         Pos [2]float32
7586
7587                                         //mt:if %s.Field == HUDName
7588                                         Name string
7589
7590                                         //mt:if %s.Field == HUDScale
7591                                         Scale [2]float32
7592
7593                                         //mt:if %s.Field == HUDText
7594                                         Text string
7595
7596                                         //mt:if %s.Field == HUDNumber
7597                                         Number uint32
7598
7599                                         //mt:if %s.Field == HUDItem
7600                                         Item uint32
7601
7602                                         //mt:if %s.Field == HUDDir
7603                                         Dir uint32
7604
7605                                         //mt:if %s.Field == HUDAlign
7606                                         Align [2]float32
7607
7608                                         //mt:if %s.Field == HUDOffset
7609                                         Offset [2]float32
7610
7611                                         //mt:if %s.Field == HUDWorldPos
7612                                         WorldPos Pos
7613
7614                                         //mt:if %s.Field == HUDSize
7615                                         Size [2]int32
7616
7617                                         //mt:if %s.Field == HUDZIndex
7618                                         ZIndex int32
7619
7620                                         //mt:if %s.Field == HUDText2
7621                                         Text2 string
7622
7623                                         //mt:if %s.Field == HUDStyle
7624                                         Style HUDStyleFlags
7625                                 }))(obj)).Pos)[local172]
7626                                 write32(w, math.Float32bits(x))
7627                         }
7628                 }
7629         }
7630         if (*(*(struct {
7631                 ID HUDID
7632
7633                 Field HUDField
7634
7635                 //mt:if %s.Field == HUDPos
7636                 Pos [2]float32
7637
7638                 //mt:if %s.Field == HUDName
7639                 Name string
7640
7641                 //mt:if %s.Field == HUDScale
7642                 Scale [2]float32
7643
7644                 //mt:if %s.Field == HUDText
7645                 Text string
7646
7647                 //mt:if %s.Field == HUDNumber
7648                 Number uint32
7649
7650                 //mt:if %s.Field == HUDItem
7651                 Item uint32
7652
7653                 //mt:if %s.Field == HUDDir
7654                 Dir uint32
7655
7656                 //mt:if %s.Field == HUDAlign
7657                 Align [2]float32
7658
7659                 //mt:if %s.Field == HUDOffset
7660                 Offset [2]float32
7661
7662                 //mt:if %s.Field == HUDWorldPos
7663                 WorldPos Pos
7664
7665                 //mt:if %s.Field == HUDSize
7666                 Size [2]int32
7667
7668                 //mt:if %s.Field == HUDZIndex
7669                 ZIndex int32
7670
7671                 //mt:if %s.Field == HUDText2
7672                 Text2 string
7673
7674                 //mt:if %s.Field == HUDStyle
7675                 Style HUDStyleFlags
7676         }))(obj)).Field == HUDName {
7677                 if len(([]byte((*(*(struct {
7678                         ID HUDID
7679
7680                         Field HUDField
7681
7682                         //mt:if %s.Field == HUDPos
7683                         Pos [2]float32
7684
7685                         //mt:if %s.Field == HUDName
7686                         Name string
7687
7688                         //mt:if %s.Field == HUDScale
7689                         Scale [2]float32
7690
7691                         //mt:if %s.Field == HUDText
7692                         Text string
7693
7694                         //mt:if %s.Field == HUDNumber
7695                         Number uint32
7696
7697                         //mt:if %s.Field == HUDItem
7698                         Item uint32
7699
7700                         //mt:if %s.Field == HUDDir
7701                         Dir uint32
7702
7703                         //mt:if %s.Field == HUDAlign
7704                         Align [2]float32
7705
7706                         //mt:if %s.Field == HUDOffset
7707                         Offset [2]float32
7708
7709                         //mt:if %s.Field == HUDWorldPos
7710                         WorldPos Pos
7711
7712                         //mt:if %s.Field == HUDSize
7713                         Size [2]int32
7714
7715                         //mt:if %s.Field == HUDZIndex
7716                         ZIndex int32
7717
7718                         //mt:if %s.Field == HUDText2
7719                         Text2 string
7720
7721                         //mt:if %s.Field == HUDStyle
7722                         Style HUDStyleFlags
7723                 }))(obj)).Name))) > math.MaxUint16 {
7724                         chk(ErrTooLong)
7725                 }
7726                 {
7727                         x := uint16(len(([]byte((*(*(struct {
7728                                 ID HUDID
7729
7730                                 Field HUDField
7731
7732                                 //mt:if %s.Field == HUDPos
7733                                 Pos [2]float32
7734
7735                                 //mt:if %s.Field == HUDName
7736                                 Name string
7737
7738                                 //mt:if %s.Field == HUDScale
7739                                 Scale [2]float32
7740
7741                                 //mt:if %s.Field == HUDText
7742                                 Text string
7743
7744                                 //mt:if %s.Field == HUDNumber
7745                                 Number uint32
7746
7747                                 //mt:if %s.Field == HUDItem
7748                                 Item uint32
7749
7750                                 //mt:if %s.Field == HUDDir
7751                                 Dir uint32
7752
7753                                 //mt:if %s.Field == HUDAlign
7754                                 Align [2]float32
7755
7756                                 //mt:if %s.Field == HUDOffset
7757                                 Offset [2]float32
7758
7759                                 //mt:if %s.Field == HUDWorldPos
7760                                 WorldPos Pos
7761
7762                                 //mt:if %s.Field == HUDSize
7763                                 Size [2]int32
7764
7765                                 //mt:if %s.Field == HUDZIndex
7766                                 ZIndex int32
7767
7768                                 //mt:if %s.Field == HUDText2
7769                                 Text2 string
7770
7771                                 //mt:if %s.Field == HUDStyle
7772                                 Style HUDStyleFlags
7773                         }))(obj)).Name))))
7774                         write16(w, uint16(x))
7775                 }
7776                 {
7777                         _, err := w.Write(([]byte((*(*(struct {
7778                                 ID HUDID
7779
7780                                 Field HUDField
7781
7782                                 //mt:if %s.Field == HUDPos
7783                                 Pos [2]float32
7784
7785                                 //mt:if %s.Field == HUDName
7786                                 Name string
7787
7788                                 //mt:if %s.Field == HUDScale
7789                                 Scale [2]float32
7790
7791                                 //mt:if %s.Field == HUDText
7792                                 Text string
7793
7794                                 //mt:if %s.Field == HUDNumber
7795                                 Number uint32
7796
7797                                 //mt:if %s.Field == HUDItem
7798                                 Item uint32
7799
7800                                 //mt:if %s.Field == HUDDir
7801                                 Dir uint32
7802
7803                                 //mt:if %s.Field == HUDAlign
7804                                 Align [2]float32
7805
7806                                 //mt:if %s.Field == HUDOffset
7807                                 Offset [2]float32
7808
7809                                 //mt:if %s.Field == HUDWorldPos
7810                                 WorldPos Pos
7811
7812                                 //mt:if %s.Field == HUDSize
7813                                 Size [2]int32
7814
7815                                 //mt:if %s.Field == HUDZIndex
7816                                 ZIndex int32
7817
7818                                 //mt:if %s.Field == HUDText2
7819                                 Text2 string
7820
7821                                 //mt:if %s.Field == HUDStyle
7822                                 Style HUDStyleFlags
7823                         }))(obj)).Name))[:])
7824                         chk(err)
7825                 }
7826         }
7827         if (*(*(struct {
7828                 ID HUDID
7829
7830                 Field HUDField
7831
7832                 //mt:if %s.Field == HUDPos
7833                 Pos [2]float32
7834
7835                 //mt:if %s.Field == HUDName
7836                 Name string
7837
7838                 //mt:if %s.Field == HUDScale
7839                 Scale [2]float32
7840
7841                 //mt:if %s.Field == HUDText
7842                 Text string
7843
7844                 //mt:if %s.Field == HUDNumber
7845                 Number uint32
7846
7847                 //mt:if %s.Field == HUDItem
7848                 Item uint32
7849
7850                 //mt:if %s.Field == HUDDir
7851                 Dir uint32
7852
7853                 //mt:if %s.Field == HUDAlign
7854                 Align [2]float32
7855
7856                 //mt:if %s.Field == HUDOffset
7857                 Offset [2]float32
7858
7859                 //mt:if %s.Field == HUDWorldPos
7860                 WorldPos Pos
7861
7862                 //mt:if %s.Field == HUDSize
7863                 Size [2]int32
7864
7865                 //mt:if %s.Field == HUDZIndex
7866                 ZIndex int32
7867
7868                 //mt:if %s.Field == HUDText2
7869                 Text2 string
7870
7871                 //mt:if %s.Field == HUDStyle
7872                 Style HUDStyleFlags
7873         }))(obj)).Field == HUDScale {
7874                 for local173 := range (*(*(struct {
7875                         ID HUDID
7876
7877                         Field HUDField
7878
7879                         //mt:if %s.Field == HUDPos
7880                         Pos [2]float32
7881
7882                         //mt:if %s.Field == HUDName
7883                         Name string
7884
7885                         //mt:if %s.Field == HUDScale
7886                         Scale [2]float32
7887
7888                         //mt:if %s.Field == HUDText
7889                         Text string
7890
7891                         //mt:if %s.Field == HUDNumber
7892                         Number uint32
7893
7894                         //mt:if %s.Field == HUDItem
7895                         Item uint32
7896
7897                         //mt:if %s.Field == HUDDir
7898                         Dir uint32
7899
7900                         //mt:if %s.Field == HUDAlign
7901                         Align [2]float32
7902
7903                         //mt:if %s.Field == HUDOffset
7904                         Offset [2]float32
7905
7906                         //mt:if %s.Field == HUDWorldPos
7907                         WorldPos Pos
7908
7909                         //mt:if %s.Field == HUDSize
7910                         Size [2]int32
7911
7912                         //mt:if %s.Field == HUDZIndex
7913                         ZIndex int32
7914
7915                         //mt:if %s.Field == HUDText2
7916                         Text2 string
7917
7918                         //mt:if %s.Field == HUDStyle
7919                         Style HUDStyleFlags
7920                 }))(obj)).Scale {
7921                         {
7922                                 x := ((*(*(struct {
7923                                         ID HUDID
7924
7925                                         Field HUDField
7926
7927                                         //mt:if %s.Field == HUDPos
7928                                         Pos [2]float32
7929
7930                                         //mt:if %s.Field == HUDName
7931                                         Name string
7932
7933                                         //mt:if %s.Field == HUDScale
7934                                         Scale [2]float32
7935
7936                                         //mt:if %s.Field == HUDText
7937                                         Text string
7938
7939                                         //mt:if %s.Field == HUDNumber
7940                                         Number uint32
7941
7942                                         //mt:if %s.Field == HUDItem
7943                                         Item uint32
7944
7945                                         //mt:if %s.Field == HUDDir
7946                                         Dir uint32
7947
7948                                         //mt:if %s.Field == HUDAlign
7949                                         Align [2]float32
7950
7951                                         //mt:if %s.Field == HUDOffset
7952                                         Offset [2]float32
7953
7954                                         //mt:if %s.Field == HUDWorldPos
7955                                         WorldPos Pos
7956
7957                                         //mt:if %s.Field == HUDSize
7958                                         Size [2]int32
7959
7960                                         //mt:if %s.Field == HUDZIndex
7961                                         ZIndex int32
7962
7963                                         //mt:if %s.Field == HUDText2
7964                                         Text2 string
7965
7966                                         //mt:if %s.Field == HUDStyle
7967                                         Style HUDStyleFlags
7968                                 }))(obj)).Scale)[local173]
7969                                 write32(w, math.Float32bits(x))
7970                         }
7971                 }
7972         }
7973         if (*(*(struct {
7974                 ID HUDID
7975
7976                 Field HUDField
7977
7978                 //mt:if %s.Field == HUDPos
7979                 Pos [2]float32
7980
7981                 //mt:if %s.Field == HUDName
7982                 Name string
7983
7984                 //mt:if %s.Field == HUDScale
7985                 Scale [2]float32
7986
7987                 //mt:if %s.Field == HUDText
7988                 Text string
7989
7990                 //mt:if %s.Field == HUDNumber
7991                 Number uint32
7992
7993                 //mt:if %s.Field == HUDItem
7994                 Item uint32
7995
7996                 //mt:if %s.Field == HUDDir
7997                 Dir uint32
7998
7999                 //mt:if %s.Field == HUDAlign
8000                 Align [2]float32
8001
8002                 //mt:if %s.Field == HUDOffset
8003                 Offset [2]float32
8004
8005                 //mt:if %s.Field == HUDWorldPos
8006                 WorldPos Pos
8007
8008                 //mt:if %s.Field == HUDSize
8009                 Size [2]int32
8010
8011                 //mt:if %s.Field == HUDZIndex
8012                 ZIndex int32
8013
8014                 //mt:if %s.Field == HUDText2
8015                 Text2 string
8016
8017                 //mt:if %s.Field == HUDStyle
8018                 Style HUDStyleFlags
8019         }))(obj)).Field == HUDText {
8020                 if len(([]byte((*(*(struct {
8021                         ID HUDID
8022
8023                         Field HUDField
8024
8025                         //mt:if %s.Field == HUDPos
8026                         Pos [2]float32
8027
8028                         //mt:if %s.Field == HUDName
8029                         Name string
8030
8031                         //mt:if %s.Field == HUDScale
8032                         Scale [2]float32
8033
8034                         //mt:if %s.Field == HUDText
8035                         Text string
8036
8037                         //mt:if %s.Field == HUDNumber
8038                         Number uint32
8039
8040                         //mt:if %s.Field == HUDItem
8041                         Item uint32
8042
8043                         //mt:if %s.Field == HUDDir
8044                         Dir uint32
8045
8046                         //mt:if %s.Field == HUDAlign
8047                         Align [2]float32
8048
8049                         //mt:if %s.Field == HUDOffset
8050                         Offset [2]float32
8051
8052                         //mt:if %s.Field == HUDWorldPos
8053                         WorldPos Pos
8054
8055                         //mt:if %s.Field == HUDSize
8056                         Size [2]int32
8057
8058                         //mt:if %s.Field == HUDZIndex
8059                         ZIndex int32
8060
8061                         //mt:if %s.Field == HUDText2
8062                         Text2 string
8063
8064                         //mt:if %s.Field == HUDStyle
8065                         Style HUDStyleFlags
8066                 }))(obj)).Text))) > math.MaxUint16 {
8067                         chk(ErrTooLong)
8068                 }
8069                 {
8070                         x := uint16(len(([]byte((*(*(struct {
8071                                 ID HUDID
8072
8073                                 Field HUDField
8074
8075                                 //mt:if %s.Field == HUDPos
8076                                 Pos [2]float32
8077
8078                                 //mt:if %s.Field == HUDName
8079                                 Name string
8080
8081                                 //mt:if %s.Field == HUDScale
8082                                 Scale [2]float32
8083
8084                                 //mt:if %s.Field == HUDText
8085                                 Text string
8086
8087                                 //mt:if %s.Field == HUDNumber
8088                                 Number uint32
8089
8090                                 //mt:if %s.Field == HUDItem
8091                                 Item uint32
8092
8093                                 //mt:if %s.Field == HUDDir
8094                                 Dir uint32
8095
8096                                 //mt:if %s.Field == HUDAlign
8097                                 Align [2]float32
8098
8099                                 //mt:if %s.Field == HUDOffset
8100                                 Offset [2]float32
8101
8102                                 //mt:if %s.Field == HUDWorldPos
8103                                 WorldPos Pos
8104
8105                                 //mt:if %s.Field == HUDSize
8106                                 Size [2]int32
8107
8108                                 //mt:if %s.Field == HUDZIndex
8109                                 ZIndex int32
8110
8111                                 //mt:if %s.Field == HUDText2
8112                                 Text2 string
8113
8114                                 //mt:if %s.Field == HUDStyle
8115                                 Style HUDStyleFlags
8116                         }))(obj)).Text))))
8117                         write16(w, uint16(x))
8118                 }
8119                 {
8120                         _, err := w.Write(([]byte((*(*(struct {
8121                                 ID HUDID
8122
8123                                 Field HUDField
8124
8125                                 //mt:if %s.Field == HUDPos
8126                                 Pos [2]float32
8127
8128                                 //mt:if %s.Field == HUDName
8129                                 Name string
8130
8131                                 //mt:if %s.Field == HUDScale
8132                                 Scale [2]float32
8133
8134                                 //mt:if %s.Field == HUDText
8135                                 Text string
8136
8137                                 //mt:if %s.Field == HUDNumber
8138                                 Number uint32
8139
8140                                 //mt:if %s.Field == HUDItem
8141                                 Item uint32
8142
8143                                 //mt:if %s.Field == HUDDir
8144                                 Dir uint32
8145
8146                                 //mt:if %s.Field == HUDAlign
8147                                 Align [2]float32
8148
8149                                 //mt:if %s.Field == HUDOffset
8150                                 Offset [2]float32
8151
8152                                 //mt:if %s.Field == HUDWorldPos
8153                                 WorldPos Pos
8154
8155                                 //mt:if %s.Field == HUDSize
8156                                 Size [2]int32
8157
8158                                 //mt:if %s.Field == HUDZIndex
8159                                 ZIndex int32
8160
8161                                 //mt:if %s.Field == HUDText2
8162                                 Text2 string
8163
8164                                 //mt:if %s.Field == HUDStyle
8165                                 Style HUDStyleFlags
8166                         }))(obj)).Text))[:])
8167                         chk(err)
8168                 }
8169         }
8170         if (*(*(struct {
8171                 ID HUDID
8172
8173                 Field HUDField
8174
8175                 //mt:if %s.Field == HUDPos
8176                 Pos [2]float32
8177
8178                 //mt:if %s.Field == HUDName
8179                 Name string
8180
8181                 //mt:if %s.Field == HUDScale
8182                 Scale [2]float32
8183
8184                 //mt:if %s.Field == HUDText
8185                 Text string
8186
8187                 //mt:if %s.Field == HUDNumber
8188                 Number uint32
8189
8190                 //mt:if %s.Field == HUDItem
8191                 Item uint32
8192
8193                 //mt:if %s.Field == HUDDir
8194                 Dir uint32
8195
8196                 //mt:if %s.Field == HUDAlign
8197                 Align [2]float32
8198
8199                 //mt:if %s.Field == HUDOffset
8200                 Offset [2]float32
8201
8202                 //mt:if %s.Field == HUDWorldPos
8203                 WorldPos Pos
8204
8205                 //mt:if %s.Field == HUDSize
8206                 Size [2]int32
8207
8208                 //mt:if %s.Field == HUDZIndex
8209                 ZIndex int32
8210
8211                 //mt:if %s.Field == HUDText2
8212                 Text2 string
8213
8214                 //mt:if %s.Field == HUDStyle
8215                 Style HUDStyleFlags
8216         }))(obj)).Field == HUDNumber {
8217                 {
8218                         x := (*(*(struct {
8219                                 ID HUDID
8220
8221                                 Field HUDField
8222
8223                                 //mt:if %s.Field == HUDPos
8224                                 Pos [2]float32
8225
8226                                 //mt:if %s.Field == HUDName
8227                                 Name string
8228
8229                                 //mt:if %s.Field == HUDScale
8230                                 Scale [2]float32
8231
8232                                 //mt:if %s.Field == HUDText
8233                                 Text string
8234
8235                                 //mt:if %s.Field == HUDNumber
8236                                 Number uint32
8237
8238                                 //mt:if %s.Field == HUDItem
8239                                 Item uint32
8240
8241                                 //mt:if %s.Field == HUDDir
8242                                 Dir uint32
8243
8244                                 //mt:if %s.Field == HUDAlign
8245                                 Align [2]float32
8246
8247                                 //mt:if %s.Field == HUDOffset
8248                                 Offset [2]float32
8249
8250                                 //mt:if %s.Field == HUDWorldPos
8251                                 WorldPos Pos
8252
8253                                 //mt:if %s.Field == HUDSize
8254                                 Size [2]int32
8255
8256                                 //mt:if %s.Field == HUDZIndex
8257                                 ZIndex int32
8258
8259                                 //mt:if %s.Field == HUDText2
8260                                 Text2 string
8261
8262                                 //mt:if %s.Field == HUDStyle
8263                                 Style HUDStyleFlags
8264                         }))(obj)).Number
8265                         write32(w, uint32(x))
8266                 }
8267         }
8268         if (*(*(struct {
8269                 ID HUDID
8270
8271                 Field HUDField
8272
8273                 //mt:if %s.Field == HUDPos
8274                 Pos [2]float32
8275
8276                 //mt:if %s.Field == HUDName
8277                 Name string
8278
8279                 //mt:if %s.Field == HUDScale
8280                 Scale [2]float32
8281
8282                 //mt:if %s.Field == HUDText
8283                 Text string
8284
8285                 //mt:if %s.Field == HUDNumber
8286                 Number uint32
8287
8288                 //mt:if %s.Field == HUDItem
8289                 Item uint32
8290
8291                 //mt:if %s.Field == HUDDir
8292                 Dir uint32
8293
8294                 //mt:if %s.Field == HUDAlign
8295                 Align [2]float32
8296
8297                 //mt:if %s.Field == HUDOffset
8298                 Offset [2]float32
8299
8300                 //mt:if %s.Field == HUDWorldPos
8301                 WorldPos Pos
8302
8303                 //mt:if %s.Field == HUDSize
8304                 Size [2]int32
8305
8306                 //mt:if %s.Field == HUDZIndex
8307                 ZIndex int32
8308
8309                 //mt:if %s.Field == HUDText2
8310                 Text2 string
8311
8312                 //mt:if %s.Field == HUDStyle
8313                 Style HUDStyleFlags
8314         }))(obj)).Field == HUDItem {
8315                 {
8316                         x := (*(*(struct {
8317                                 ID HUDID
8318
8319                                 Field HUDField
8320
8321                                 //mt:if %s.Field == HUDPos
8322                                 Pos [2]float32
8323
8324                                 //mt:if %s.Field == HUDName
8325                                 Name string
8326
8327                                 //mt:if %s.Field == HUDScale
8328                                 Scale [2]float32
8329
8330                                 //mt:if %s.Field == HUDText
8331                                 Text string
8332
8333                                 //mt:if %s.Field == HUDNumber
8334                                 Number uint32
8335
8336                                 //mt:if %s.Field == HUDItem
8337                                 Item uint32
8338
8339                                 //mt:if %s.Field == HUDDir
8340                                 Dir uint32
8341
8342                                 //mt:if %s.Field == HUDAlign
8343                                 Align [2]float32
8344
8345                                 //mt:if %s.Field == HUDOffset
8346                                 Offset [2]float32
8347
8348                                 //mt:if %s.Field == HUDWorldPos
8349                                 WorldPos Pos
8350
8351                                 //mt:if %s.Field == HUDSize
8352                                 Size [2]int32
8353
8354                                 //mt:if %s.Field == HUDZIndex
8355                                 ZIndex int32
8356
8357                                 //mt:if %s.Field == HUDText2
8358                                 Text2 string
8359
8360                                 //mt:if %s.Field == HUDStyle
8361                                 Style HUDStyleFlags
8362                         }))(obj)).Item
8363                         write32(w, uint32(x))
8364                 }
8365         }
8366         if (*(*(struct {
8367                 ID HUDID
8368
8369                 Field HUDField
8370
8371                 //mt:if %s.Field == HUDPos
8372                 Pos [2]float32
8373
8374                 //mt:if %s.Field == HUDName
8375                 Name string
8376
8377                 //mt:if %s.Field == HUDScale
8378                 Scale [2]float32
8379
8380                 //mt:if %s.Field == HUDText
8381                 Text string
8382
8383                 //mt:if %s.Field == HUDNumber
8384                 Number uint32
8385
8386                 //mt:if %s.Field == HUDItem
8387                 Item uint32
8388
8389                 //mt:if %s.Field == HUDDir
8390                 Dir uint32
8391
8392                 //mt:if %s.Field == HUDAlign
8393                 Align [2]float32
8394
8395                 //mt:if %s.Field == HUDOffset
8396                 Offset [2]float32
8397
8398                 //mt:if %s.Field == HUDWorldPos
8399                 WorldPos Pos
8400
8401                 //mt:if %s.Field == HUDSize
8402                 Size [2]int32
8403
8404                 //mt:if %s.Field == HUDZIndex
8405                 ZIndex int32
8406
8407                 //mt:if %s.Field == HUDText2
8408                 Text2 string
8409
8410                 //mt:if %s.Field == HUDStyle
8411                 Style HUDStyleFlags
8412         }))(obj)).Field == HUDDir {
8413                 {
8414                         x := (*(*(struct {
8415                                 ID HUDID
8416
8417                                 Field HUDField
8418
8419                                 //mt:if %s.Field == HUDPos
8420                                 Pos [2]float32
8421
8422                                 //mt:if %s.Field == HUDName
8423                                 Name string
8424
8425                                 //mt:if %s.Field == HUDScale
8426                                 Scale [2]float32
8427
8428                                 //mt:if %s.Field == HUDText
8429                                 Text string
8430
8431                                 //mt:if %s.Field == HUDNumber
8432                                 Number uint32
8433
8434                                 //mt:if %s.Field == HUDItem
8435                                 Item uint32
8436
8437                                 //mt:if %s.Field == HUDDir
8438                                 Dir uint32
8439
8440                                 //mt:if %s.Field == HUDAlign
8441                                 Align [2]float32
8442
8443                                 //mt:if %s.Field == HUDOffset
8444                                 Offset [2]float32
8445
8446                                 //mt:if %s.Field == HUDWorldPos
8447                                 WorldPos Pos
8448
8449                                 //mt:if %s.Field == HUDSize
8450                                 Size [2]int32
8451
8452                                 //mt:if %s.Field == HUDZIndex
8453                                 ZIndex int32
8454
8455                                 //mt:if %s.Field == HUDText2
8456                                 Text2 string
8457
8458                                 //mt:if %s.Field == HUDStyle
8459                                 Style HUDStyleFlags
8460                         }))(obj)).Dir
8461                         write32(w, uint32(x))
8462                 }
8463         }
8464         if (*(*(struct {
8465                 ID HUDID
8466
8467                 Field HUDField
8468
8469                 //mt:if %s.Field == HUDPos
8470                 Pos [2]float32
8471
8472                 //mt:if %s.Field == HUDName
8473                 Name string
8474
8475                 //mt:if %s.Field == HUDScale
8476                 Scale [2]float32
8477
8478                 //mt:if %s.Field == HUDText
8479                 Text string
8480
8481                 //mt:if %s.Field == HUDNumber
8482                 Number uint32
8483
8484                 //mt:if %s.Field == HUDItem
8485                 Item uint32
8486
8487                 //mt:if %s.Field == HUDDir
8488                 Dir uint32
8489
8490                 //mt:if %s.Field == HUDAlign
8491                 Align [2]float32
8492
8493                 //mt:if %s.Field == HUDOffset
8494                 Offset [2]float32
8495
8496                 //mt:if %s.Field == HUDWorldPos
8497                 WorldPos Pos
8498
8499                 //mt:if %s.Field == HUDSize
8500                 Size [2]int32
8501
8502                 //mt:if %s.Field == HUDZIndex
8503                 ZIndex int32
8504
8505                 //mt:if %s.Field == HUDText2
8506                 Text2 string
8507
8508                 //mt:if %s.Field == HUDStyle
8509                 Style HUDStyleFlags
8510         }))(obj)).Field == HUDAlign {
8511                 for local174 := range (*(*(struct {
8512                         ID HUDID
8513
8514                         Field HUDField
8515
8516                         //mt:if %s.Field == HUDPos
8517                         Pos [2]float32
8518
8519                         //mt:if %s.Field == HUDName
8520                         Name string
8521
8522                         //mt:if %s.Field == HUDScale
8523                         Scale [2]float32
8524
8525                         //mt:if %s.Field == HUDText
8526                         Text string
8527
8528                         //mt:if %s.Field == HUDNumber
8529                         Number uint32
8530
8531                         //mt:if %s.Field == HUDItem
8532                         Item uint32
8533
8534                         //mt:if %s.Field == HUDDir
8535                         Dir uint32
8536
8537                         //mt:if %s.Field == HUDAlign
8538                         Align [2]float32
8539
8540                         //mt:if %s.Field == HUDOffset
8541                         Offset [2]float32
8542
8543                         //mt:if %s.Field == HUDWorldPos
8544                         WorldPos Pos
8545
8546                         //mt:if %s.Field == HUDSize
8547                         Size [2]int32
8548
8549                         //mt:if %s.Field == HUDZIndex
8550                         ZIndex int32
8551
8552                         //mt:if %s.Field == HUDText2
8553                         Text2 string
8554
8555                         //mt:if %s.Field == HUDStyle
8556                         Style HUDStyleFlags
8557                 }))(obj)).Align {
8558                         {
8559                                 x := ((*(*(struct {
8560                                         ID HUDID
8561
8562                                         Field HUDField
8563
8564                                         //mt:if %s.Field == HUDPos
8565                                         Pos [2]float32
8566
8567                                         //mt:if %s.Field == HUDName
8568                                         Name string
8569
8570                                         //mt:if %s.Field == HUDScale
8571                                         Scale [2]float32
8572
8573                                         //mt:if %s.Field == HUDText
8574                                         Text string
8575
8576                                         //mt:if %s.Field == HUDNumber
8577                                         Number uint32
8578
8579                                         //mt:if %s.Field == HUDItem
8580                                         Item uint32
8581
8582                                         //mt:if %s.Field == HUDDir
8583                                         Dir uint32
8584
8585                                         //mt:if %s.Field == HUDAlign
8586                                         Align [2]float32
8587
8588                                         //mt:if %s.Field == HUDOffset
8589                                         Offset [2]float32
8590
8591                                         //mt:if %s.Field == HUDWorldPos
8592                                         WorldPos Pos
8593
8594                                         //mt:if %s.Field == HUDSize
8595                                         Size [2]int32
8596
8597                                         //mt:if %s.Field == HUDZIndex
8598                                         ZIndex int32
8599
8600                                         //mt:if %s.Field == HUDText2
8601                                         Text2 string
8602
8603                                         //mt:if %s.Field == HUDStyle
8604                                         Style HUDStyleFlags
8605                                 }))(obj)).Align)[local174]
8606                                 write32(w, math.Float32bits(x))
8607                         }
8608                 }
8609         }
8610         if (*(*(struct {
8611                 ID HUDID
8612
8613                 Field HUDField
8614
8615                 //mt:if %s.Field == HUDPos
8616                 Pos [2]float32
8617
8618                 //mt:if %s.Field == HUDName
8619                 Name string
8620
8621                 //mt:if %s.Field == HUDScale
8622                 Scale [2]float32
8623
8624                 //mt:if %s.Field == HUDText
8625                 Text string
8626
8627                 //mt:if %s.Field == HUDNumber
8628                 Number uint32
8629
8630                 //mt:if %s.Field == HUDItem
8631                 Item uint32
8632
8633                 //mt:if %s.Field == HUDDir
8634                 Dir uint32
8635
8636                 //mt:if %s.Field == HUDAlign
8637                 Align [2]float32
8638
8639                 //mt:if %s.Field == HUDOffset
8640                 Offset [2]float32
8641
8642                 //mt:if %s.Field == HUDWorldPos
8643                 WorldPos Pos
8644
8645                 //mt:if %s.Field == HUDSize
8646                 Size [2]int32
8647
8648                 //mt:if %s.Field == HUDZIndex
8649                 ZIndex int32
8650
8651                 //mt:if %s.Field == HUDText2
8652                 Text2 string
8653
8654                 //mt:if %s.Field == HUDStyle
8655                 Style HUDStyleFlags
8656         }))(obj)).Field == HUDOffset {
8657                 for local175 := range (*(*(struct {
8658                         ID HUDID
8659
8660                         Field HUDField
8661
8662                         //mt:if %s.Field == HUDPos
8663                         Pos [2]float32
8664
8665                         //mt:if %s.Field == HUDName
8666                         Name string
8667
8668                         //mt:if %s.Field == HUDScale
8669                         Scale [2]float32
8670
8671                         //mt:if %s.Field == HUDText
8672                         Text string
8673
8674                         //mt:if %s.Field == HUDNumber
8675                         Number uint32
8676
8677                         //mt:if %s.Field == HUDItem
8678                         Item uint32
8679
8680                         //mt:if %s.Field == HUDDir
8681                         Dir uint32
8682
8683                         //mt:if %s.Field == HUDAlign
8684                         Align [2]float32
8685
8686                         //mt:if %s.Field == HUDOffset
8687                         Offset [2]float32
8688
8689                         //mt:if %s.Field == HUDWorldPos
8690                         WorldPos Pos
8691
8692                         //mt:if %s.Field == HUDSize
8693                         Size [2]int32
8694
8695                         //mt:if %s.Field == HUDZIndex
8696                         ZIndex int32
8697
8698                         //mt:if %s.Field == HUDText2
8699                         Text2 string
8700
8701                         //mt:if %s.Field == HUDStyle
8702                         Style HUDStyleFlags
8703                 }))(obj)).Offset {
8704                         {
8705                                 x := ((*(*(struct {
8706                                         ID HUDID
8707
8708                                         Field HUDField
8709
8710                                         //mt:if %s.Field == HUDPos
8711                                         Pos [2]float32
8712
8713                                         //mt:if %s.Field == HUDName
8714                                         Name string
8715
8716                                         //mt:if %s.Field == HUDScale
8717                                         Scale [2]float32
8718
8719                                         //mt:if %s.Field == HUDText
8720                                         Text string
8721
8722                                         //mt:if %s.Field == HUDNumber
8723                                         Number uint32
8724
8725                                         //mt:if %s.Field == HUDItem
8726                                         Item uint32
8727
8728                                         //mt:if %s.Field == HUDDir
8729                                         Dir uint32
8730
8731                                         //mt:if %s.Field == HUDAlign
8732                                         Align [2]float32
8733
8734                                         //mt:if %s.Field == HUDOffset
8735                                         Offset [2]float32
8736
8737                                         //mt:if %s.Field == HUDWorldPos
8738                                         WorldPos Pos
8739
8740                                         //mt:if %s.Field == HUDSize
8741                                         Size [2]int32
8742
8743                                         //mt:if %s.Field == HUDZIndex
8744                                         ZIndex int32
8745
8746                                         //mt:if %s.Field == HUDText2
8747                                         Text2 string
8748
8749                                         //mt:if %s.Field == HUDStyle
8750                                         Style HUDStyleFlags
8751                                 }))(obj)).Offset)[local175]
8752                                 write32(w, math.Float32bits(x))
8753                         }
8754                 }
8755         }
8756         if (*(*(struct {
8757                 ID HUDID
8758
8759                 Field HUDField
8760
8761                 //mt:if %s.Field == HUDPos
8762                 Pos [2]float32
8763
8764                 //mt:if %s.Field == HUDName
8765                 Name string
8766
8767                 //mt:if %s.Field == HUDScale
8768                 Scale [2]float32
8769
8770                 //mt:if %s.Field == HUDText
8771                 Text string
8772
8773                 //mt:if %s.Field == HUDNumber
8774                 Number uint32
8775
8776                 //mt:if %s.Field == HUDItem
8777                 Item uint32
8778
8779                 //mt:if %s.Field == HUDDir
8780                 Dir uint32
8781
8782                 //mt:if %s.Field == HUDAlign
8783                 Align [2]float32
8784
8785                 //mt:if %s.Field == HUDOffset
8786                 Offset [2]float32
8787
8788                 //mt:if %s.Field == HUDWorldPos
8789                 WorldPos Pos
8790
8791                 //mt:if %s.Field == HUDSize
8792                 Size [2]int32
8793
8794                 //mt:if %s.Field == HUDZIndex
8795                 ZIndex int32
8796
8797                 //mt:if %s.Field == HUDText2
8798                 Text2 string
8799
8800                 //mt:if %s.Field == HUDStyle
8801                 Style HUDStyleFlags
8802         }))(obj)).Field == HUDWorldPos {
8803                 if err := pcall(func() {
8804                         ((*(*(struct {
8805                                 ID HUDID
8806
8807                                 Field HUDField
8808
8809                                 //mt:if %s.Field == HUDPos
8810                                 Pos [2]float32
8811
8812                                 //mt:if %s.Field == HUDName
8813                                 Name string
8814
8815                                 //mt:if %s.Field == HUDScale
8816                                 Scale [2]float32
8817
8818                                 //mt:if %s.Field == HUDText
8819                                 Text string
8820
8821                                 //mt:if %s.Field == HUDNumber
8822                                 Number uint32
8823
8824                                 //mt:if %s.Field == HUDItem
8825                                 Item uint32
8826
8827                                 //mt:if %s.Field == HUDDir
8828                                 Dir uint32
8829
8830                                 //mt:if %s.Field == HUDAlign
8831                                 Align [2]float32
8832
8833                                 //mt:if %s.Field == HUDOffset
8834                                 Offset [2]float32
8835
8836                                 //mt:if %s.Field == HUDWorldPos
8837                                 WorldPos Pos
8838
8839                                 //mt:if %s.Field == HUDSize
8840                                 Size [2]int32
8841
8842                                 //mt:if %s.Field == HUDZIndex
8843                                 ZIndex int32
8844
8845                                 //mt:if %s.Field == HUDText2
8846                                 Text2 string
8847
8848                                 //mt:if %s.Field == HUDStyle
8849                                 Style HUDStyleFlags
8850                         }))(obj)).WorldPos).Serialize(w)
8851                 }); err != nil {
8852                         if err == io.EOF {
8853                                 chk(io.EOF)
8854                         }
8855                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
8856                 }
8857         }
8858         if (*(*(struct {
8859                 ID HUDID
8860
8861                 Field HUDField
8862
8863                 //mt:if %s.Field == HUDPos
8864                 Pos [2]float32
8865
8866                 //mt:if %s.Field == HUDName
8867                 Name string
8868
8869                 //mt:if %s.Field == HUDScale
8870                 Scale [2]float32
8871
8872                 //mt:if %s.Field == HUDText
8873                 Text string
8874
8875                 //mt:if %s.Field == HUDNumber
8876                 Number uint32
8877
8878                 //mt:if %s.Field == HUDItem
8879                 Item uint32
8880
8881                 //mt:if %s.Field == HUDDir
8882                 Dir uint32
8883
8884                 //mt:if %s.Field == HUDAlign
8885                 Align [2]float32
8886
8887                 //mt:if %s.Field == HUDOffset
8888                 Offset [2]float32
8889
8890                 //mt:if %s.Field == HUDWorldPos
8891                 WorldPos Pos
8892
8893                 //mt:if %s.Field == HUDSize
8894                 Size [2]int32
8895
8896                 //mt:if %s.Field == HUDZIndex
8897                 ZIndex int32
8898
8899                 //mt:if %s.Field == HUDText2
8900                 Text2 string
8901
8902                 //mt:if %s.Field == HUDStyle
8903                 Style HUDStyleFlags
8904         }))(obj)).Field == HUDSize {
8905                 for local176 := range (*(*(struct {
8906                         ID HUDID
8907
8908                         Field HUDField
8909
8910                         //mt:if %s.Field == HUDPos
8911                         Pos [2]float32
8912
8913                         //mt:if %s.Field == HUDName
8914                         Name string
8915
8916                         //mt:if %s.Field == HUDScale
8917                         Scale [2]float32
8918
8919                         //mt:if %s.Field == HUDText
8920                         Text string
8921
8922                         //mt:if %s.Field == HUDNumber
8923                         Number uint32
8924
8925                         //mt:if %s.Field == HUDItem
8926                         Item uint32
8927
8928                         //mt:if %s.Field == HUDDir
8929                         Dir uint32
8930
8931                         //mt:if %s.Field == HUDAlign
8932                         Align [2]float32
8933
8934                         //mt:if %s.Field == HUDOffset
8935                         Offset [2]float32
8936
8937                         //mt:if %s.Field == HUDWorldPos
8938                         WorldPos Pos
8939
8940                         //mt:if %s.Field == HUDSize
8941                         Size [2]int32
8942
8943                         //mt:if %s.Field == HUDZIndex
8944                         ZIndex int32
8945
8946                         //mt:if %s.Field == HUDText2
8947                         Text2 string
8948
8949                         //mt:if %s.Field == HUDStyle
8950                         Style HUDStyleFlags
8951                 }))(obj)).Size {
8952                         {
8953                                 x := ((*(*(struct {
8954                                         ID HUDID
8955
8956                                         Field HUDField
8957
8958                                         //mt:if %s.Field == HUDPos
8959                                         Pos [2]float32
8960
8961                                         //mt:if %s.Field == HUDName
8962                                         Name string
8963
8964                                         //mt:if %s.Field == HUDScale
8965                                         Scale [2]float32
8966
8967                                         //mt:if %s.Field == HUDText
8968                                         Text string
8969
8970                                         //mt:if %s.Field == HUDNumber
8971                                         Number uint32
8972
8973                                         //mt:if %s.Field == HUDItem
8974                                         Item uint32
8975
8976                                         //mt:if %s.Field == HUDDir
8977                                         Dir uint32
8978
8979                                         //mt:if %s.Field == HUDAlign
8980                                         Align [2]float32
8981
8982                                         //mt:if %s.Field == HUDOffset
8983                                         Offset [2]float32
8984
8985                                         //mt:if %s.Field == HUDWorldPos
8986                                         WorldPos Pos
8987
8988                                         //mt:if %s.Field == HUDSize
8989                                         Size [2]int32
8990
8991                                         //mt:if %s.Field == HUDZIndex
8992                                         ZIndex int32
8993
8994                                         //mt:if %s.Field == HUDText2
8995                                         Text2 string
8996
8997                                         //mt:if %s.Field == HUDStyle
8998                                         Style HUDStyleFlags
8999                                 }))(obj)).Size)[local176]
9000                                 write32(w, uint32(x))
9001                         }
9002                 }
9003         }
9004         if (*(*(struct {
9005                 ID HUDID
9006
9007                 Field HUDField
9008
9009                 //mt:if %s.Field == HUDPos
9010                 Pos [2]float32
9011
9012                 //mt:if %s.Field == HUDName
9013                 Name string
9014
9015                 //mt:if %s.Field == HUDScale
9016                 Scale [2]float32
9017
9018                 //mt:if %s.Field == HUDText
9019                 Text string
9020
9021                 //mt:if %s.Field == HUDNumber
9022                 Number uint32
9023
9024                 //mt:if %s.Field == HUDItem
9025                 Item uint32
9026
9027                 //mt:if %s.Field == HUDDir
9028                 Dir uint32
9029
9030                 //mt:if %s.Field == HUDAlign
9031                 Align [2]float32
9032
9033                 //mt:if %s.Field == HUDOffset
9034                 Offset [2]float32
9035
9036                 //mt:if %s.Field == HUDWorldPos
9037                 WorldPos Pos
9038
9039                 //mt:if %s.Field == HUDSize
9040                 Size [2]int32
9041
9042                 //mt:if %s.Field == HUDZIndex
9043                 ZIndex int32
9044
9045                 //mt:if %s.Field == HUDText2
9046                 Text2 string
9047
9048                 //mt:if %s.Field == HUDStyle
9049                 Style HUDStyleFlags
9050         }))(obj)).Field == HUDZIndex {
9051                 {
9052                         x := (*(*(struct {
9053                                 ID HUDID
9054
9055                                 Field HUDField
9056
9057                                 //mt:if %s.Field == HUDPos
9058                                 Pos [2]float32
9059
9060                                 //mt:if %s.Field == HUDName
9061                                 Name string
9062
9063                                 //mt:if %s.Field == HUDScale
9064                                 Scale [2]float32
9065
9066                                 //mt:if %s.Field == HUDText
9067                                 Text string
9068
9069                                 //mt:if %s.Field == HUDNumber
9070                                 Number uint32
9071
9072                                 //mt:if %s.Field == HUDItem
9073                                 Item uint32
9074
9075                                 //mt:if %s.Field == HUDDir
9076                                 Dir uint32
9077
9078                                 //mt:if %s.Field == HUDAlign
9079                                 Align [2]float32
9080
9081                                 //mt:if %s.Field == HUDOffset
9082                                 Offset [2]float32
9083
9084                                 //mt:if %s.Field == HUDWorldPos
9085                                 WorldPos Pos
9086
9087                                 //mt:if %s.Field == HUDSize
9088                                 Size [2]int32
9089
9090                                 //mt:if %s.Field == HUDZIndex
9091                                 ZIndex int32
9092
9093                                 //mt:if %s.Field == HUDText2
9094                                 Text2 string
9095
9096                                 //mt:if %s.Field == HUDStyle
9097                                 Style HUDStyleFlags
9098                         }))(obj)).ZIndex
9099                         write32(w, uint32(x))
9100                 }
9101         }
9102         if (*(*(struct {
9103                 ID HUDID
9104
9105                 Field HUDField
9106
9107                 //mt:if %s.Field == HUDPos
9108                 Pos [2]float32
9109
9110                 //mt:if %s.Field == HUDName
9111                 Name string
9112
9113                 //mt:if %s.Field == HUDScale
9114                 Scale [2]float32
9115
9116                 //mt:if %s.Field == HUDText
9117                 Text string
9118
9119                 //mt:if %s.Field == HUDNumber
9120                 Number uint32
9121
9122                 //mt:if %s.Field == HUDItem
9123                 Item uint32
9124
9125                 //mt:if %s.Field == HUDDir
9126                 Dir uint32
9127
9128                 //mt:if %s.Field == HUDAlign
9129                 Align [2]float32
9130
9131                 //mt:if %s.Field == HUDOffset
9132                 Offset [2]float32
9133
9134                 //mt:if %s.Field == HUDWorldPos
9135                 WorldPos Pos
9136
9137                 //mt:if %s.Field == HUDSize
9138                 Size [2]int32
9139
9140                 //mt:if %s.Field == HUDZIndex
9141                 ZIndex int32
9142
9143                 //mt:if %s.Field == HUDText2
9144                 Text2 string
9145
9146                 //mt:if %s.Field == HUDStyle
9147                 Style HUDStyleFlags
9148         }))(obj)).Field == HUDText2 {
9149                 if len(([]byte((*(*(struct {
9150                         ID HUDID
9151
9152                         Field HUDField
9153
9154                         //mt:if %s.Field == HUDPos
9155                         Pos [2]float32
9156
9157                         //mt:if %s.Field == HUDName
9158                         Name string
9159
9160                         //mt:if %s.Field == HUDScale
9161                         Scale [2]float32
9162
9163                         //mt:if %s.Field == HUDText
9164                         Text string
9165
9166                         //mt:if %s.Field == HUDNumber
9167                         Number uint32
9168
9169                         //mt:if %s.Field == HUDItem
9170                         Item uint32
9171
9172                         //mt:if %s.Field == HUDDir
9173                         Dir uint32
9174
9175                         //mt:if %s.Field == HUDAlign
9176                         Align [2]float32
9177
9178                         //mt:if %s.Field == HUDOffset
9179                         Offset [2]float32
9180
9181                         //mt:if %s.Field == HUDWorldPos
9182                         WorldPos Pos
9183
9184                         //mt:if %s.Field == HUDSize
9185                         Size [2]int32
9186
9187                         //mt:if %s.Field == HUDZIndex
9188                         ZIndex int32
9189
9190                         //mt:if %s.Field == HUDText2
9191                         Text2 string
9192
9193                         //mt:if %s.Field == HUDStyle
9194                         Style HUDStyleFlags
9195                 }))(obj)).Text2))) > math.MaxUint16 {
9196                         chk(ErrTooLong)
9197                 }
9198                 {
9199                         x := uint16(len(([]byte((*(*(struct {
9200                                 ID HUDID
9201
9202                                 Field HUDField
9203
9204                                 //mt:if %s.Field == HUDPos
9205                                 Pos [2]float32
9206
9207                                 //mt:if %s.Field == HUDName
9208                                 Name string
9209
9210                                 //mt:if %s.Field == HUDScale
9211                                 Scale [2]float32
9212
9213                                 //mt:if %s.Field == HUDText
9214                                 Text string
9215
9216                                 //mt:if %s.Field == HUDNumber
9217                                 Number uint32
9218
9219                                 //mt:if %s.Field == HUDItem
9220                                 Item uint32
9221
9222                                 //mt:if %s.Field == HUDDir
9223                                 Dir uint32
9224
9225                                 //mt:if %s.Field == HUDAlign
9226                                 Align [2]float32
9227
9228                                 //mt:if %s.Field == HUDOffset
9229                                 Offset [2]float32
9230
9231                                 //mt:if %s.Field == HUDWorldPos
9232                                 WorldPos Pos
9233
9234                                 //mt:if %s.Field == HUDSize
9235                                 Size [2]int32
9236
9237                                 //mt:if %s.Field == HUDZIndex
9238                                 ZIndex int32
9239
9240                                 //mt:if %s.Field == HUDText2
9241                                 Text2 string
9242
9243                                 //mt:if %s.Field == HUDStyle
9244                                 Style HUDStyleFlags
9245                         }))(obj)).Text2))))
9246                         write16(w, uint16(x))
9247                 }
9248                 {
9249                         _, err := w.Write(([]byte((*(*(struct {
9250                                 ID HUDID
9251
9252                                 Field HUDField
9253
9254                                 //mt:if %s.Field == HUDPos
9255                                 Pos [2]float32
9256
9257                                 //mt:if %s.Field == HUDName
9258                                 Name string
9259
9260                                 //mt:if %s.Field == HUDScale
9261                                 Scale [2]float32
9262
9263                                 //mt:if %s.Field == HUDText
9264                                 Text string
9265
9266                                 //mt:if %s.Field == HUDNumber
9267                                 Number uint32
9268
9269                                 //mt:if %s.Field == HUDItem
9270                                 Item uint32
9271
9272                                 //mt:if %s.Field == HUDDir
9273                                 Dir uint32
9274
9275                                 //mt:if %s.Field == HUDAlign
9276                                 Align [2]float32
9277
9278                                 //mt:if %s.Field == HUDOffset
9279                                 Offset [2]float32
9280
9281                                 //mt:if %s.Field == HUDWorldPos
9282                                 WorldPos Pos
9283
9284                                 //mt:if %s.Field == HUDSize
9285                                 Size [2]int32
9286
9287                                 //mt:if %s.Field == HUDZIndex
9288                                 ZIndex int32
9289
9290                                 //mt:if %s.Field == HUDText2
9291                                 Text2 string
9292
9293                                 //mt:if %s.Field == HUDStyle
9294                                 Style HUDStyleFlags
9295                         }))(obj)).Text2))[:])
9296                         chk(err)
9297                 }
9298         }
9299         if (*(*(struct {
9300                 ID HUDID
9301
9302                 Field HUDField
9303
9304                 //mt:if %s.Field == HUDPos
9305                 Pos [2]float32
9306
9307                 //mt:if %s.Field == HUDName
9308                 Name string
9309
9310                 //mt:if %s.Field == HUDScale
9311                 Scale [2]float32
9312
9313                 //mt:if %s.Field == HUDText
9314                 Text string
9315
9316                 //mt:if %s.Field == HUDNumber
9317                 Number uint32
9318
9319                 //mt:if %s.Field == HUDItem
9320                 Item uint32
9321
9322                 //mt:if %s.Field == HUDDir
9323                 Dir uint32
9324
9325                 //mt:if %s.Field == HUDAlign
9326                 Align [2]float32
9327
9328                 //mt:if %s.Field == HUDOffset
9329                 Offset [2]float32
9330
9331                 //mt:if %s.Field == HUDWorldPos
9332                 WorldPos Pos
9333
9334                 //mt:if %s.Field == HUDSize
9335                 Size [2]int32
9336
9337                 //mt:if %s.Field == HUDZIndex
9338                 ZIndex int32
9339
9340                 //mt:if %s.Field == HUDText2
9341                 Text2 string
9342
9343                 //mt:if %s.Field == HUDStyle
9344                 Style HUDStyleFlags
9345         }))(obj)).Field == HUDStyle {
9346                 if err := pcall(func() {
9347                         ((*(*(struct {
9348                                 ID HUDID
9349
9350                                 Field HUDField
9351
9352                                 //mt:if %s.Field == HUDPos
9353                                 Pos [2]float32
9354
9355                                 //mt:if %s.Field == HUDName
9356                                 Name string
9357
9358                                 //mt:if %s.Field == HUDScale
9359                                 Scale [2]float32
9360
9361                                 //mt:if %s.Field == HUDText
9362                                 Text string
9363
9364                                 //mt:if %s.Field == HUDNumber
9365                                 Number uint32
9366
9367                                 //mt:if %s.Field == HUDItem
9368                                 Item uint32
9369
9370                                 //mt:if %s.Field == HUDDir
9371                                 Dir uint32
9372
9373                                 //mt:if %s.Field == HUDAlign
9374                                 Align [2]float32
9375
9376                                 //mt:if %s.Field == HUDOffset
9377                                 Offset [2]float32
9378
9379                                 //mt:if %s.Field == HUDWorldPos
9380                                 WorldPos Pos
9381
9382                                 //mt:if %s.Field == HUDSize
9383                                 Size [2]int32
9384
9385                                 //mt:if %s.Field == HUDZIndex
9386                                 ZIndex int32
9387
9388                                 //mt:if %s.Field == HUDText2
9389                                 Text2 string
9390
9391                                 //mt:if %s.Field == HUDStyle
9392                                 Style HUDStyleFlags
9393                         }))(obj)).Style).Serialize(w)
9394                 }); err != nil {
9395                         if err == io.EOF {
9396                                 chk(io.EOF)
9397                         }
9398                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
9399                 }
9400         }
9401 }
9402
9403 func (obj *ToCltChangeHUD) Deserialize(r io.Reader) {
9404         if err := pcall(func() {
9405                 ((*(*(struct {
9406                         ID HUDID
9407
9408                         Field HUDField
9409
9410                         //mt:if %s.Field == HUDPos
9411                         Pos [2]float32
9412
9413                         //mt:if %s.Field == HUDName
9414                         Name string
9415
9416                         //mt:if %s.Field == HUDScale
9417                         Scale [2]float32
9418
9419                         //mt:if %s.Field == HUDText
9420                         Text string
9421
9422                         //mt:if %s.Field == HUDNumber
9423                         Number uint32
9424
9425                         //mt:if %s.Field == HUDItem
9426                         Item uint32
9427
9428                         //mt:if %s.Field == HUDDir
9429                         Dir uint32
9430
9431                         //mt:if %s.Field == HUDAlign
9432                         Align [2]float32
9433
9434                         //mt:if %s.Field == HUDOffset
9435                         Offset [2]float32
9436
9437                         //mt:if %s.Field == HUDWorldPos
9438                         WorldPos Pos
9439
9440                         //mt:if %s.Field == HUDSize
9441                         Size [2]int32
9442
9443                         //mt:if %s.Field == HUDZIndex
9444                         ZIndex int32
9445
9446                         //mt:if %s.Field == HUDText2
9447                         Text2 string
9448
9449                         //mt:if %s.Field == HUDStyle
9450                         Style HUDStyleFlags
9451                 }))(obj)).ID).Deserialize(r)
9452         }); err != nil {
9453                 if err == io.EOF {
9454                         chk(io.EOF)
9455                 }
9456                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
9457         }
9458         if err := pcall(func() {
9459                 ((*(*(struct {
9460                         ID HUDID
9461
9462                         Field HUDField
9463
9464                         //mt:if %s.Field == HUDPos
9465                         Pos [2]float32
9466
9467                         //mt:if %s.Field == HUDName
9468                         Name string
9469
9470                         //mt:if %s.Field == HUDScale
9471                         Scale [2]float32
9472
9473                         //mt:if %s.Field == HUDText
9474                         Text string
9475
9476                         //mt:if %s.Field == HUDNumber
9477                         Number uint32
9478
9479                         //mt:if %s.Field == HUDItem
9480                         Item uint32
9481
9482                         //mt:if %s.Field == HUDDir
9483                         Dir uint32
9484
9485                         //mt:if %s.Field == HUDAlign
9486                         Align [2]float32
9487
9488                         //mt:if %s.Field == HUDOffset
9489                         Offset [2]float32
9490
9491                         //mt:if %s.Field == HUDWorldPos
9492                         WorldPos Pos
9493
9494                         //mt:if %s.Field == HUDSize
9495                         Size [2]int32
9496
9497                         //mt:if %s.Field == HUDZIndex
9498                         ZIndex int32
9499
9500                         //mt:if %s.Field == HUDText2
9501                         Text2 string
9502
9503                         //mt:if %s.Field == HUDStyle
9504                         Style HUDStyleFlags
9505                 }))(obj)).Field).Deserialize(r)
9506         }); err != nil {
9507                 if err == io.EOF {
9508                         chk(io.EOF)
9509                 }
9510                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDField", err))
9511         }
9512         if !((*(*(struct {
9513                 ID HUDID
9514
9515                 Field HUDField
9516
9517                 //mt:if %s.Field == HUDPos
9518                 Pos [2]float32
9519
9520                 //mt:if %s.Field == HUDName
9521                 Name string
9522
9523                 //mt:if %s.Field == HUDScale
9524                 Scale [2]float32
9525
9526                 //mt:if %s.Field == HUDText
9527                 Text string
9528
9529                 //mt:if %s.Field == HUDNumber
9530                 Number uint32
9531
9532                 //mt:if %s.Field == HUDItem
9533                 Item uint32
9534
9535                 //mt:if %s.Field == HUDDir
9536                 Dir uint32
9537
9538                 //mt:if %s.Field == HUDAlign
9539                 Align [2]float32
9540
9541                 //mt:if %s.Field == HUDOffset
9542                 Offset [2]float32
9543
9544                 //mt:if %s.Field == HUDWorldPos
9545                 WorldPos Pos
9546
9547                 //mt:if %s.Field == HUDSize
9548                 Size [2]int32
9549
9550                 //mt:if %s.Field == HUDZIndex
9551                 ZIndex int32
9552
9553                 //mt:if %s.Field == HUDText2
9554                 Text2 string
9555
9556                 //mt:if %s.Field == HUDStyle
9557                 Style HUDStyleFlags
9558         }))(obj)).Field < hudMax) {
9559                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9560         }
9561         if (*(*(struct {
9562                 ID HUDID
9563
9564                 Field HUDField
9565
9566                 //mt:if %s.Field == HUDPos
9567                 Pos [2]float32
9568
9569                 //mt:if %s.Field == HUDName
9570                 Name string
9571
9572                 //mt:if %s.Field == HUDScale
9573                 Scale [2]float32
9574
9575                 //mt:if %s.Field == HUDText
9576                 Text string
9577
9578                 //mt:if %s.Field == HUDNumber
9579                 Number uint32
9580
9581                 //mt:if %s.Field == HUDItem
9582                 Item uint32
9583
9584                 //mt:if %s.Field == HUDDir
9585                 Dir uint32
9586
9587                 //mt:if %s.Field == HUDAlign
9588                 Align [2]float32
9589
9590                 //mt:if %s.Field == HUDOffset
9591                 Offset [2]float32
9592
9593                 //mt:if %s.Field == HUDWorldPos
9594                 WorldPos Pos
9595
9596                 //mt:if %s.Field == HUDSize
9597                 Size [2]int32
9598
9599                 //mt:if %s.Field == HUDZIndex
9600                 ZIndex int32
9601
9602                 //mt:if %s.Field == HUDText2
9603                 Text2 string
9604
9605                 //mt:if %s.Field == HUDStyle
9606                 Style HUDStyleFlags
9607         }))(obj)).Field == HUDPos {
9608                 for local177 := range (*(*(struct {
9609                         ID HUDID
9610
9611                         Field HUDField
9612
9613                         //mt:if %s.Field == HUDPos
9614                         Pos [2]float32
9615
9616                         //mt:if %s.Field == HUDName
9617                         Name string
9618
9619                         //mt:if %s.Field == HUDScale
9620                         Scale [2]float32
9621
9622                         //mt:if %s.Field == HUDText
9623                         Text string
9624
9625                         //mt:if %s.Field == HUDNumber
9626                         Number uint32
9627
9628                         //mt:if %s.Field == HUDItem
9629                         Item uint32
9630
9631                         //mt:if %s.Field == HUDDir
9632                         Dir uint32
9633
9634                         //mt:if %s.Field == HUDAlign
9635                         Align [2]float32
9636
9637                         //mt:if %s.Field == HUDOffset
9638                         Offset [2]float32
9639
9640                         //mt:if %s.Field == HUDWorldPos
9641                         WorldPos Pos
9642
9643                         //mt:if %s.Field == HUDSize
9644                         Size [2]int32
9645
9646                         //mt:if %s.Field == HUDZIndex
9647                         ZIndex int32
9648
9649                         //mt:if %s.Field == HUDText2
9650                         Text2 string
9651
9652                         //mt:if %s.Field == HUDStyle
9653                         Style HUDStyleFlags
9654                 }))(obj)).Pos {
9655                         {
9656                                 p := &((*(*(struct {
9657                                         ID HUDID
9658
9659                                         Field HUDField
9660
9661                                         //mt:if %s.Field == HUDPos
9662                                         Pos [2]float32
9663
9664                                         //mt:if %s.Field == HUDName
9665                                         Name string
9666
9667                                         //mt:if %s.Field == HUDScale
9668                                         Scale [2]float32
9669
9670                                         //mt:if %s.Field == HUDText
9671                                         Text string
9672
9673                                         //mt:if %s.Field == HUDNumber
9674                                         Number uint32
9675
9676                                         //mt:if %s.Field == HUDItem
9677                                         Item uint32
9678
9679                                         //mt:if %s.Field == HUDDir
9680                                         Dir uint32
9681
9682                                         //mt:if %s.Field == HUDAlign
9683                                         Align [2]float32
9684
9685                                         //mt:if %s.Field == HUDOffset
9686                                         Offset [2]float32
9687
9688                                         //mt:if %s.Field == HUDWorldPos
9689                                         WorldPos Pos
9690
9691                                         //mt:if %s.Field == HUDSize
9692                                         Size [2]int32
9693
9694                                         //mt:if %s.Field == HUDZIndex
9695                                         ZIndex int32
9696
9697                                         //mt:if %s.Field == HUDText2
9698                                         Text2 string
9699
9700                                         //mt:if %s.Field == HUDStyle
9701                                         Style HUDStyleFlags
9702                                 }))(obj)).Pos)[local177]
9703                                 *p = math.Float32frombits(read32(r))
9704                         }
9705                 }
9706         }
9707         if (*(*(struct {
9708                 ID HUDID
9709
9710                 Field HUDField
9711
9712                 //mt:if %s.Field == HUDPos
9713                 Pos [2]float32
9714
9715                 //mt:if %s.Field == HUDName
9716                 Name string
9717
9718                 //mt:if %s.Field == HUDScale
9719                 Scale [2]float32
9720
9721                 //mt:if %s.Field == HUDText
9722                 Text string
9723
9724                 //mt:if %s.Field == HUDNumber
9725                 Number uint32
9726
9727                 //mt:if %s.Field == HUDItem
9728                 Item uint32
9729
9730                 //mt:if %s.Field == HUDDir
9731                 Dir uint32
9732
9733                 //mt:if %s.Field == HUDAlign
9734                 Align [2]float32
9735
9736                 //mt:if %s.Field == HUDOffset
9737                 Offset [2]float32
9738
9739                 //mt:if %s.Field == HUDWorldPos
9740                 WorldPos Pos
9741
9742                 //mt:if %s.Field == HUDSize
9743                 Size [2]int32
9744
9745                 //mt:if %s.Field == HUDZIndex
9746                 ZIndex int32
9747
9748                 //mt:if %s.Field == HUDText2
9749                 Text2 string
9750
9751                 //mt:if %s.Field == HUDStyle
9752                 Style HUDStyleFlags
9753         }))(obj)).Field == HUDName {
9754                 var local178 []uint8
9755                 var local179 uint16
9756                 {
9757                         p := &local179
9758                         *p = read16(r)
9759                 }
9760                 (local178) = make([]uint8, local179)
9761                 {
9762                         _, err := io.ReadFull(r, (local178)[:])
9763                         chk(err)
9764                 }
9765                 ((*(*(struct {
9766                         ID HUDID
9767
9768                         Field HUDField
9769
9770                         //mt:if %s.Field == HUDPos
9771                         Pos [2]float32
9772
9773                         //mt:if %s.Field == HUDName
9774                         Name string
9775
9776                         //mt:if %s.Field == HUDScale
9777                         Scale [2]float32
9778
9779                         //mt:if %s.Field == HUDText
9780                         Text string
9781
9782                         //mt:if %s.Field == HUDNumber
9783                         Number uint32
9784
9785                         //mt:if %s.Field == HUDItem
9786                         Item uint32
9787
9788                         //mt:if %s.Field == HUDDir
9789                         Dir uint32
9790
9791                         //mt:if %s.Field == HUDAlign
9792                         Align [2]float32
9793
9794                         //mt:if %s.Field == HUDOffset
9795                         Offset [2]float32
9796
9797                         //mt:if %s.Field == HUDWorldPos
9798                         WorldPos Pos
9799
9800                         //mt:if %s.Field == HUDSize
9801                         Size [2]int32
9802
9803                         //mt:if %s.Field == HUDZIndex
9804                         ZIndex int32
9805
9806                         //mt:if %s.Field == HUDText2
9807                         Text2 string
9808
9809                         //mt:if %s.Field == HUDStyle
9810                         Style HUDStyleFlags
9811                 }))(obj)).Name) = string(local178)
9812         }
9813         if (*(*(struct {
9814                 ID HUDID
9815
9816                 Field HUDField
9817
9818                 //mt:if %s.Field == HUDPos
9819                 Pos [2]float32
9820
9821                 //mt:if %s.Field == HUDName
9822                 Name string
9823
9824                 //mt:if %s.Field == HUDScale
9825                 Scale [2]float32
9826
9827                 //mt:if %s.Field == HUDText
9828                 Text string
9829
9830                 //mt:if %s.Field == HUDNumber
9831                 Number uint32
9832
9833                 //mt:if %s.Field == HUDItem
9834                 Item uint32
9835
9836                 //mt:if %s.Field == HUDDir
9837                 Dir uint32
9838
9839                 //mt:if %s.Field == HUDAlign
9840                 Align [2]float32
9841
9842                 //mt:if %s.Field == HUDOffset
9843                 Offset [2]float32
9844
9845                 //mt:if %s.Field == HUDWorldPos
9846                 WorldPos Pos
9847
9848                 //mt:if %s.Field == HUDSize
9849                 Size [2]int32
9850
9851                 //mt:if %s.Field == HUDZIndex
9852                 ZIndex int32
9853
9854                 //mt:if %s.Field == HUDText2
9855                 Text2 string
9856
9857                 //mt:if %s.Field == HUDStyle
9858                 Style HUDStyleFlags
9859         }))(obj)).Field == HUDScale {
9860                 for local180 := range (*(*(struct {
9861                         ID HUDID
9862
9863                         Field HUDField
9864
9865                         //mt:if %s.Field == HUDPos
9866                         Pos [2]float32
9867
9868                         //mt:if %s.Field == HUDName
9869                         Name string
9870
9871                         //mt:if %s.Field == HUDScale
9872                         Scale [2]float32
9873
9874                         //mt:if %s.Field == HUDText
9875                         Text string
9876
9877                         //mt:if %s.Field == HUDNumber
9878                         Number uint32
9879
9880                         //mt:if %s.Field == HUDItem
9881                         Item uint32
9882
9883                         //mt:if %s.Field == HUDDir
9884                         Dir uint32
9885
9886                         //mt:if %s.Field == HUDAlign
9887                         Align [2]float32
9888
9889                         //mt:if %s.Field == HUDOffset
9890                         Offset [2]float32
9891
9892                         //mt:if %s.Field == HUDWorldPos
9893                         WorldPos Pos
9894
9895                         //mt:if %s.Field == HUDSize
9896                         Size [2]int32
9897
9898                         //mt:if %s.Field == HUDZIndex
9899                         ZIndex int32
9900
9901                         //mt:if %s.Field == HUDText2
9902                         Text2 string
9903
9904                         //mt:if %s.Field == HUDStyle
9905                         Style HUDStyleFlags
9906                 }))(obj)).Scale {
9907                         {
9908                                 p := &((*(*(struct {
9909                                         ID HUDID
9910
9911                                         Field HUDField
9912
9913                                         //mt:if %s.Field == HUDPos
9914                                         Pos [2]float32
9915
9916                                         //mt:if %s.Field == HUDName
9917                                         Name string
9918
9919                                         //mt:if %s.Field == HUDScale
9920                                         Scale [2]float32
9921
9922                                         //mt:if %s.Field == HUDText
9923                                         Text string
9924
9925                                         //mt:if %s.Field == HUDNumber
9926                                         Number uint32
9927
9928                                         //mt:if %s.Field == HUDItem
9929                                         Item uint32
9930
9931                                         //mt:if %s.Field == HUDDir
9932                                         Dir uint32
9933
9934                                         //mt:if %s.Field == HUDAlign
9935                                         Align [2]float32
9936
9937                                         //mt:if %s.Field == HUDOffset
9938                                         Offset [2]float32
9939
9940                                         //mt:if %s.Field == HUDWorldPos
9941                                         WorldPos Pos
9942
9943                                         //mt:if %s.Field == HUDSize
9944                                         Size [2]int32
9945
9946                                         //mt:if %s.Field == HUDZIndex
9947                                         ZIndex int32
9948
9949                                         //mt:if %s.Field == HUDText2
9950                                         Text2 string
9951
9952                                         //mt:if %s.Field == HUDStyle
9953                                         Style HUDStyleFlags
9954                                 }))(obj)).Scale)[local180]
9955                                 *p = math.Float32frombits(read32(r))
9956                         }
9957                 }
9958         }
9959         if (*(*(struct {
9960                 ID HUDID
9961
9962                 Field HUDField
9963
9964                 //mt:if %s.Field == HUDPos
9965                 Pos [2]float32
9966
9967                 //mt:if %s.Field == HUDName
9968                 Name string
9969
9970                 //mt:if %s.Field == HUDScale
9971                 Scale [2]float32
9972
9973                 //mt:if %s.Field == HUDText
9974                 Text string
9975
9976                 //mt:if %s.Field == HUDNumber
9977                 Number uint32
9978
9979                 //mt:if %s.Field == HUDItem
9980                 Item uint32
9981
9982                 //mt:if %s.Field == HUDDir
9983                 Dir uint32
9984
9985                 //mt:if %s.Field == HUDAlign
9986                 Align [2]float32
9987
9988                 //mt:if %s.Field == HUDOffset
9989                 Offset [2]float32
9990
9991                 //mt:if %s.Field == HUDWorldPos
9992                 WorldPos Pos
9993
9994                 //mt:if %s.Field == HUDSize
9995                 Size [2]int32
9996
9997                 //mt:if %s.Field == HUDZIndex
9998                 ZIndex int32
9999
10000                 //mt:if %s.Field == HUDText2
10001                 Text2 string
10002
10003                 //mt:if %s.Field == HUDStyle
10004                 Style HUDStyleFlags
10005         }))(obj)).Field == HUDText {
10006                 var local181 []uint8
10007                 var local182 uint16
10008                 {
10009                         p := &local182
10010                         *p = read16(r)
10011                 }
10012                 (local181) = make([]uint8, local182)
10013                 {
10014                         _, err := io.ReadFull(r, (local181)[:])
10015                         chk(err)
10016                 }
10017                 ((*(*(struct {
10018                         ID HUDID
10019
10020                         Field HUDField
10021
10022                         //mt:if %s.Field == HUDPos
10023                         Pos [2]float32
10024
10025                         //mt:if %s.Field == HUDName
10026                         Name string
10027
10028                         //mt:if %s.Field == HUDScale
10029                         Scale [2]float32
10030
10031                         //mt:if %s.Field == HUDText
10032                         Text string
10033
10034                         //mt:if %s.Field == HUDNumber
10035                         Number uint32
10036
10037                         //mt:if %s.Field == HUDItem
10038                         Item uint32
10039
10040                         //mt:if %s.Field == HUDDir
10041                         Dir uint32
10042
10043                         //mt:if %s.Field == HUDAlign
10044                         Align [2]float32
10045
10046                         //mt:if %s.Field == HUDOffset
10047                         Offset [2]float32
10048
10049                         //mt:if %s.Field == HUDWorldPos
10050                         WorldPos Pos
10051
10052                         //mt:if %s.Field == HUDSize
10053                         Size [2]int32
10054
10055                         //mt:if %s.Field == HUDZIndex
10056                         ZIndex int32
10057
10058                         //mt:if %s.Field == HUDText2
10059                         Text2 string
10060
10061                         //mt:if %s.Field == HUDStyle
10062                         Style HUDStyleFlags
10063                 }))(obj)).Text) = string(local181)
10064         }
10065         if (*(*(struct {
10066                 ID HUDID
10067
10068                 Field HUDField
10069
10070                 //mt:if %s.Field == HUDPos
10071                 Pos [2]float32
10072
10073                 //mt:if %s.Field == HUDName
10074                 Name string
10075
10076                 //mt:if %s.Field == HUDScale
10077                 Scale [2]float32
10078
10079                 //mt:if %s.Field == HUDText
10080                 Text string
10081
10082                 //mt:if %s.Field == HUDNumber
10083                 Number uint32
10084
10085                 //mt:if %s.Field == HUDItem
10086                 Item uint32
10087
10088                 //mt:if %s.Field == HUDDir
10089                 Dir uint32
10090
10091                 //mt:if %s.Field == HUDAlign
10092                 Align [2]float32
10093
10094                 //mt:if %s.Field == HUDOffset
10095                 Offset [2]float32
10096
10097                 //mt:if %s.Field == HUDWorldPos
10098                 WorldPos Pos
10099
10100                 //mt:if %s.Field == HUDSize
10101                 Size [2]int32
10102
10103                 //mt:if %s.Field == HUDZIndex
10104                 ZIndex int32
10105
10106                 //mt:if %s.Field == HUDText2
10107                 Text2 string
10108
10109                 //mt:if %s.Field == HUDStyle
10110                 Style HUDStyleFlags
10111         }))(obj)).Field == HUDNumber {
10112                 {
10113                         p := &(*(*(struct {
10114                                 ID HUDID
10115
10116                                 Field HUDField
10117
10118                                 //mt:if %s.Field == HUDPos
10119                                 Pos [2]float32
10120
10121                                 //mt:if %s.Field == HUDName
10122                                 Name string
10123
10124                                 //mt:if %s.Field == HUDScale
10125                                 Scale [2]float32
10126
10127                                 //mt:if %s.Field == HUDText
10128                                 Text string
10129
10130                                 //mt:if %s.Field == HUDNumber
10131                                 Number uint32
10132
10133                                 //mt:if %s.Field == HUDItem
10134                                 Item uint32
10135
10136                                 //mt:if %s.Field == HUDDir
10137                                 Dir uint32
10138
10139                                 //mt:if %s.Field == HUDAlign
10140                                 Align [2]float32
10141
10142                                 //mt:if %s.Field == HUDOffset
10143                                 Offset [2]float32
10144
10145                                 //mt:if %s.Field == HUDWorldPos
10146                                 WorldPos Pos
10147
10148                                 //mt:if %s.Field == HUDSize
10149                                 Size [2]int32
10150
10151                                 //mt:if %s.Field == HUDZIndex
10152                                 ZIndex int32
10153
10154                                 //mt:if %s.Field == HUDText2
10155                                 Text2 string
10156
10157                                 //mt:if %s.Field == HUDStyle
10158                                 Style HUDStyleFlags
10159                         }))(obj)).Number
10160                         *p = read32(r)
10161                 }
10162         }
10163         if (*(*(struct {
10164                 ID HUDID
10165
10166                 Field HUDField
10167
10168                 //mt:if %s.Field == HUDPos
10169                 Pos [2]float32
10170
10171                 //mt:if %s.Field == HUDName
10172                 Name string
10173
10174                 //mt:if %s.Field == HUDScale
10175                 Scale [2]float32
10176
10177                 //mt:if %s.Field == HUDText
10178                 Text string
10179
10180                 //mt:if %s.Field == HUDNumber
10181                 Number uint32
10182
10183                 //mt:if %s.Field == HUDItem
10184                 Item uint32
10185
10186                 //mt:if %s.Field == HUDDir
10187                 Dir uint32
10188
10189                 //mt:if %s.Field == HUDAlign
10190                 Align [2]float32
10191
10192                 //mt:if %s.Field == HUDOffset
10193                 Offset [2]float32
10194
10195                 //mt:if %s.Field == HUDWorldPos
10196                 WorldPos Pos
10197
10198                 //mt:if %s.Field == HUDSize
10199                 Size [2]int32
10200
10201                 //mt:if %s.Field == HUDZIndex
10202                 ZIndex int32
10203
10204                 //mt:if %s.Field == HUDText2
10205                 Text2 string
10206
10207                 //mt:if %s.Field == HUDStyle
10208                 Style HUDStyleFlags
10209         }))(obj)).Field == HUDItem {
10210                 {
10211                         p := &(*(*(struct {
10212                                 ID HUDID
10213
10214                                 Field HUDField
10215
10216                                 //mt:if %s.Field == HUDPos
10217                                 Pos [2]float32
10218
10219                                 //mt:if %s.Field == HUDName
10220                                 Name string
10221
10222                                 //mt:if %s.Field == HUDScale
10223                                 Scale [2]float32
10224
10225                                 //mt:if %s.Field == HUDText
10226                                 Text string
10227
10228                                 //mt:if %s.Field == HUDNumber
10229                                 Number uint32
10230
10231                                 //mt:if %s.Field == HUDItem
10232                                 Item uint32
10233
10234                                 //mt:if %s.Field == HUDDir
10235                                 Dir uint32
10236
10237                                 //mt:if %s.Field == HUDAlign
10238                                 Align [2]float32
10239
10240                                 //mt:if %s.Field == HUDOffset
10241                                 Offset [2]float32
10242
10243                                 //mt:if %s.Field == HUDWorldPos
10244                                 WorldPos Pos
10245
10246                                 //mt:if %s.Field == HUDSize
10247                                 Size [2]int32
10248
10249                                 //mt:if %s.Field == HUDZIndex
10250                                 ZIndex int32
10251
10252                                 //mt:if %s.Field == HUDText2
10253                                 Text2 string
10254
10255                                 //mt:if %s.Field == HUDStyle
10256                                 Style HUDStyleFlags
10257                         }))(obj)).Item
10258                         *p = read32(r)
10259                 }
10260         }
10261         if (*(*(struct {
10262                 ID HUDID
10263
10264                 Field HUDField
10265
10266                 //mt:if %s.Field == HUDPos
10267                 Pos [2]float32
10268
10269                 //mt:if %s.Field == HUDName
10270                 Name string
10271
10272                 //mt:if %s.Field == HUDScale
10273                 Scale [2]float32
10274
10275                 //mt:if %s.Field == HUDText
10276                 Text string
10277
10278                 //mt:if %s.Field == HUDNumber
10279                 Number uint32
10280
10281                 //mt:if %s.Field == HUDItem
10282                 Item uint32
10283
10284                 //mt:if %s.Field == HUDDir
10285                 Dir uint32
10286
10287                 //mt:if %s.Field == HUDAlign
10288                 Align [2]float32
10289
10290                 //mt:if %s.Field == HUDOffset
10291                 Offset [2]float32
10292
10293                 //mt:if %s.Field == HUDWorldPos
10294                 WorldPos Pos
10295
10296                 //mt:if %s.Field == HUDSize
10297                 Size [2]int32
10298
10299                 //mt:if %s.Field == HUDZIndex
10300                 ZIndex int32
10301
10302                 //mt:if %s.Field == HUDText2
10303                 Text2 string
10304
10305                 //mt:if %s.Field == HUDStyle
10306                 Style HUDStyleFlags
10307         }))(obj)).Field == HUDDir {
10308                 {
10309                         p := &(*(*(struct {
10310                                 ID HUDID
10311
10312                                 Field HUDField
10313
10314                                 //mt:if %s.Field == HUDPos
10315                                 Pos [2]float32
10316
10317                                 //mt:if %s.Field == HUDName
10318                                 Name string
10319
10320                                 //mt:if %s.Field == HUDScale
10321                                 Scale [2]float32
10322
10323                                 //mt:if %s.Field == HUDText
10324                                 Text string
10325
10326                                 //mt:if %s.Field == HUDNumber
10327                                 Number uint32
10328
10329                                 //mt:if %s.Field == HUDItem
10330                                 Item uint32
10331
10332                                 //mt:if %s.Field == HUDDir
10333                                 Dir uint32
10334
10335                                 //mt:if %s.Field == HUDAlign
10336                                 Align [2]float32
10337
10338                                 //mt:if %s.Field == HUDOffset
10339                                 Offset [2]float32
10340
10341                                 //mt:if %s.Field == HUDWorldPos
10342                                 WorldPos Pos
10343
10344                                 //mt:if %s.Field == HUDSize
10345                                 Size [2]int32
10346
10347                                 //mt:if %s.Field == HUDZIndex
10348                                 ZIndex int32
10349
10350                                 //mt:if %s.Field == HUDText2
10351                                 Text2 string
10352
10353                                 //mt:if %s.Field == HUDStyle
10354                                 Style HUDStyleFlags
10355                         }))(obj)).Dir
10356                         *p = read32(r)
10357                 }
10358         }
10359         if (*(*(struct {
10360                 ID HUDID
10361
10362                 Field HUDField
10363
10364                 //mt:if %s.Field == HUDPos
10365                 Pos [2]float32
10366
10367                 //mt:if %s.Field == HUDName
10368                 Name string
10369
10370                 //mt:if %s.Field == HUDScale
10371                 Scale [2]float32
10372
10373                 //mt:if %s.Field == HUDText
10374                 Text string
10375
10376                 //mt:if %s.Field == HUDNumber
10377                 Number uint32
10378
10379                 //mt:if %s.Field == HUDItem
10380                 Item uint32
10381
10382                 //mt:if %s.Field == HUDDir
10383                 Dir uint32
10384
10385                 //mt:if %s.Field == HUDAlign
10386                 Align [2]float32
10387
10388                 //mt:if %s.Field == HUDOffset
10389                 Offset [2]float32
10390
10391                 //mt:if %s.Field == HUDWorldPos
10392                 WorldPos Pos
10393
10394                 //mt:if %s.Field == HUDSize
10395                 Size [2]int32
10396
10397                 //mt:if %s.Field == HUDZIndex
10398                 ZIndex int32
10399
10400                 //mt:if %s.Field == HUDText2
10401                 Text2 string
10402
10403                 //mt:if %s.Field == HUDStyle
10404                 Style HUDStyleFlags
10405         }))(obj)).Field == HUDAlign {
10406                 for local183 := range (*(*(struct {
10407                         ID HUDID
10408
10409                         Field HUDField
10410
10411                         //mt:if %s.Field == HUDPos
10412                         Pos [2]float32
10413
10414                         //mt:if %s.Field == HUDName
10415                         Name string
10416
10417                         //mt:if %s.Field == HUDScale
10418                         Scale [2]float32
10419
10420                         //mt:if %s.Field == HUDText
10421                         Text string
10422
10423                         //mt:if %s.Field == HUDNumber
10424                         Number uint32
10425
10426                         //mt:if %s.Field == HUDItem
10427                         Item uint32
10428
10429                         //mt:if %s.Field == HUDDir
10430                         Dir uint32
10431
10432                         //mt:if %s.Field == HUDAlign
10433                         Align [2]float32
10434
10435                         //mt:if %s.Field == HUDOffset
10436                         Offset [2]float32
10437
10438                         //mt:if %s.Field == HUDWorldPos
10439                         WorldPos Pos
10440
10441                         //mt:if %s.Field == HUDSize
10442                         Size [2]int32
10443
10444                         //mt:if %s.Field == HUDZIndex
10445                         ZIndex int32
10446
10447                         //mt:if %s.Field == HUDText2
10448                         Text2 string
10449
10450                         //mt:if %s.Field == HUDStyle
10451                         Style HUDStyleFlags
10452                 }))(obj)).Align {
10453                         {
10454                                 p := &((*(*(struct {
10455                                         ID HUDID
10456
10457                                         Field HUDField
10458
10459                                         //mt:if %s.Field == HUDPos
10460                                         Pos [2]float32
10461
10462                                         //mt:if %s.Field == HUDName
10463                                         Name string
10464
10465                                         //mt:if %s.Field == HUDScale
10466                                         Scale [2]float32
10467
10468                                         //mt:if %s.Field == HUDText
10469                                         Text string
10470
10471                                         //mt:if %s.Field == HUDNumber
10472                                         Number uint32
10473
10474                                         //mt:if %s.Field == HUDItem
10475                                         Item uint32
10476
10477                                         //mt:if %s.Field == HUDDir
10478                                         Dir uint32
10479
10480                                         //mt:if %s.Field == HUDAlign
10481                                         Align [2]float32
10482
10483                                         //mt:if %s.Field == HUDOffset
10484                                         Offset [2]float32
10485
10486                                         //mt:if %s.Field == HUDWorldPos
10487                                         WorldPos Pos
10488
10489                                         //mt:if %s.Field == HUDSize
10490                                         Size [2]int32
10491
10492                                         //mt:if %s.Field == HUDZIndex
10493                                         ZIndex int32
10494
10495                                         //mt:if %s.Field == HUDText2
10496                                         Text2 string
10497
10498                                         //mt:if %s.Field == HUDStyle
10499                                         Style HUDStyleFlags
10500                                 }))(obj)).Align)[local183]
10501                                 *p = math.Float32frombits(read32(r))
10502                         }
10503                 }
10504         }
10505         if (*(*(struct {
10506                 ID HUDID
10507
10508                 Field HUDField
10509
10510                 //mt:if %s.Field == HUDPos
10511                 Pos [2]float32
10512
10513                 //mt:if %s.Field == HUDName
10514                 Name string
10515
10516                 //mt:if %s.Field == HUDScale
10517                 Scale [2]float32
10518
10519                 //mt:if %s.Field == HUDText
10520                 Text string
10521
10522                 //mt:if %s.Field == HUDNumber
10523                 Number uint32
10524
10525                 //mt:if %s.Field == HUDItem
10526                 Item uint32
10527
10528                 //mt:if %s.Field == HUDDir
10529                 Dir uint32
10530
10531                 //mt:if %s.Field == HUDAlign
10532                 Align [2]float32
10533
10534                 //mt:if %s.Field == HUDOffset
10535                 Offset [2]float32
10536
10537                 //mt:if %s.Field == HUDWorldPos
10538                 WorldPos Pos
10539
10540                 //mt:if %s.Field == HUDSize
10541                 Size [2]int32
10542
10543                 //mt:if %s.Field == HUDZIndex
10544                 ZIndex int32
10545
10546                 //mt:if %s.Field == HUDText2
10547                 Text2 string
10548
10549                 //mt:if %s.Field == HUDStyle
10550                 Style HUDStyleFlags
10551         }))(obj)).Field == HUDOffset {
10552                 for local184 := range (*(*(struct {
10553                         ID HUDID
10554
10555                         Field HUDField
10556
10557                         //mt:if %s.Field == HUDPos
10558                         Pos [2]float32
10559
10560                         //mt:if %s.Field == HUDName
10561                         Name string
10562
10563                         //mt:if %s.Field == HUDScale
10564                         Scale [2]float32
10565
10566                         //mt:if %s.Field == HUDText
10567                         Text string
10568
10569                         //mt:if %s.Field == HUDNumber
10570                         Number uint32
10571
10572                         //mt:if %s.Field == HUDItem
10573                         Item uint32
10574
10575                         //mt:if %s.Field == HUDDir
10576                         Dir uint32
10577
10578                         //mt:if %s.Field == HUDAlign
10579                         Align [2]float32
10580
10581                         //mt:if %s.Field == HUDOffset
10582                         Offset [2]float32
10583
10584                         //mt:if %s.Field == HUDWorldPos
10585                         WorldPos Pos
10586
10587                         //mt:if %s.Field == HUDSize
10588                         Size [2]int32
10589
10590                         //mt:if %s.Field == HUDZIndex
10591                         ZIndex int32
10592
10593                         //mt:if %s.Field == HUDText2
10594                         Text2 string
10595
10596                         //mt:if %s.Field == HUDStyle
10597                         Style HUDStyleFlags
10598                 }))(obj)).Offset {
10599                         {
10600                                 p := &((*(*(struct {
10601                                         ID HUDID
10602
10603                                         Field HUDField
10604
10605                                         //mt:if %s.Field == HUDPos
10606                                         Pos [2]float32
10607
10608                                         //mt:if %s.Field == HUDName
10609                                         Name string
10610
10611                                         //mt:if %s.Field == HUDScale
10612                                         Scale [2]float32
10613
10614                                         //mt:if %s.Field == HUDText
10615                                         Text string
10616
10617                                         //mt:if %s.Field == HUDNumber
10618                                         Number uint32
10619
10620                                         //mt:if %s.Field == HUDItem
10621                                         Item uint32
10622
10623                                         //mt:if %s.Field == HUDDir
10624                                         Dir uint32
10625
10626                                         //mt:if %s.Field == HUDAlign
10627                                         Align [2]float32
10628
10629                                         //mt:if %s.Field == HUDOffset
10630                                         Offset [2]float32
10631
10632                                         //mt:if %s.Field == HUDWorldPos
10633                                         WorldPos Pos
10634
10635                                         //mt:if %s.Field == HUDSize
10636                                         Size [2]int32
10637
10638                                         //mt:if %s.Field == HUDZIndex
10639                                         ZIndex int32
10640
10641                                         //mt:if %s.Field == HUDText2
10642                                         Text2 string
10643
10644                                         //mt:if %s.Field == HUDStyle
10645                                         Style HUDStyleFlags
10646                                 }))(obj)).Offset)[local184]
10647                                 *p = math.Float32frombits(read32(r))
10648                         }
10649                 }
10650         }
10651         if (*(*(struct {
10652                 ID HUDID
10653
10654                 Field HUDField
10655
10656                 //mt:if %s.Field == HUDPos
10657                 Pos [2]float32
10658
10659                 //mt:if %s.Field == HUDName
10660                 Name string
10661
10662                 //mt:if %s.Field == HUDScale
10663                 Scale [2]float32
10664
10665                 //mt:if %s.Field == HUDText
10666                 Text string
10667
10668                 //mt:if %s.Field == HUDNumber
10669                 Number uint32
10670
10671                 //mt:if %s.Field == HUDItem
10672                 Item uint32
10673
10674                 //mt:if %s.Field == HUDDir
10675                 Dir uint32
10676
10677                 //mt:if %s.Field == HUDAlign
10678                 Align [2]float32
10679
10680                 //mt:if %s.Field == HUDOffset
10681                 Offset [2]float32
10682
10683                 //mt:if %s.Field == HUDWorldPos
10684                 WorldPos Pos
10685
10686                 //mt:if %s.Field == HUDSize
10687                 Size [2]int32
10688
10689                 //mt:if %s.Field == HUDZIndex
10690                 ZIndex int32
10691
10692                 //mt:if %s.Field == HUDText2
10693                 Text2 string
10694
10695                 //mt:if %s.Field == HUDStyle
10696                 Style HUDStyleFlags
10697         }))(obj)).Field == HUDWorldPos {
10698                 if err := pcall(func() {
10699                         ((*(*(struct {
10700                                 ID HUDID
10701
10702                                 Field HUDField
10703
10704                                 //mt:if %s.Field == HUDPos
10705                                 Pos [2]float32
10706
10707                                 //mt:if %s.Field == HUDName
10708                                 Name string
10709
10710                                 //mt:if %s.Field == HUDScale
10711                                 Scale [2]float32
10712
10713                                 //mt:if %s.Field == HUDText
10714                                 Text string
10715
10716                                 //mt:if %s.Field == HUDNumber
10717                                 Number uint32
10718
10719                                 //mt:if %s.Field == HUDItem
10720                                 Item uint32
10721
10722                                 //mt:if %s.Field == HUDDir
10723                                 Dir uint32
10724
10725                                 //mt:if %s.Field == HUDAlign
10726                                 Align [2]float32
10727
10728                                 //mt:if %s.Field == HUDOffset
10729                                 Offset [2]float32
10730
10731                                 //mt:if %s.Field == HUDWorldPos
10732                                 WorldPos Pos
10733
10734                                 //mt:if %s.Field == HUDSize
10735                                 Size [2]int32
10736
10737                                 //mt:if %s.Field == HUDZIndex
10738                                 ZIndex int32
10739
10740                                 //mt:if %s.Field == HUDText2
10741                                 Text2 string
10742
10743                                 //mt:if %s.Field == HUDStyle
10744                                 Style HUDStyleFlags
10745                         }))(obj)).WorldPos).Deserialize(r)
10746                 }); err != nil {
10747                         if err == io.EOF {
10748                                 chk(io.EOF)
10749                         }
10750                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
10751                 }
10752         }
10753         if (*(*(struct {
10754                 ID HUDID
10755
10756                 Field HUDField
10757
10758                 //mt:if %s.Field == HUDPos
10759                 Pos [2]float32
10760
10761                 //mt:if %s.Field == HUDName
10762                 Name string
10763
10764                 //mt:if %s.Field == HUDScale
10765                 Scale [2]float32
10766
10767                 //mt:if %s.Field == HUDText
10768                 Text string
10769
10770                 //mt:if %s.Field == HUDNumber
10771                 Number uint32
10772
10773                 //mt:if %s.Field == HUDItem
10774                 Item uint32
10775
10776                 //mt:if %s.Field == HUDDir
10777                 Dir uint32
10778
10779                 //mt:if %s.Field == HUDAlign
10780                 Align [2]float32
10781
10782                 //mt:if %s.Field == HUDOffset
10783                 Offset [2]float32
10784
10785                 //mt:if %s.Field == HUDWorldPos
10786                 WorldPos Pos
10787
10788                 //mt:if %s.Field == HUDSize
10789                 Size [2]int32
10790
10791                 //mt:if %s.Field == HUDZIndex
10792                 ZIndex int32
10793
10794                 //mt:if %s.Field == HUDText2
10795                 Text2 string
10796
10797                 //mt:if %s.Field == HUDStyle
10798                 Style HUDStyleFlags
10799         }))(obj)).Field == HUDSize {
10800                 for local185 := range (*(*(struct {
10801                         ID HUDID
10802
10803                         Field HUDField
10804
10805                         //mt:if %s.Field == HUDPos
10806                         Pos [2]float32
10807
10808                         //mt:if %s.Field == HUDName
10809                         Name string
10810
10811                         //mt:if %s.Field == HUDScale
10812                         Scale [2]float32
10813
10814                         //mt:if %s.Field == HUDText
10815                         Text string
10816
10817                         //mt:if %s.Field == HUDNumber
10818                         Number uint32
10819
10820                         //mt:if %s.Field == HUDItem
10821                         Item uint32
10822
10823                         //mt:if %s.Field == HUDDir
10824                         Dir uint32
10825
10826                         //mt:if %s.Field == HUDAlign
10827                         Align [2]float32
10828
10829                         //mt:if %s.Field == HUDOffset
10830                         Offset [2]float32
10831
10832                         //mt:if %s.Field == HUDWorldPos
10833                         WorldPos Pos
10834
10835                         //mt:if %s.Field == HUDSize
10836                         Size [2]int32
10837
10838                         //mt:if %s.Field == HUDZIndex
10839                         ZIndex int32
10840
10841                         //mt:if %s.Field == HUDText2
10842                         Text2 string
10843
10844                         //mt:if %s.Field == HUDStyle
10845                         Style HUDStyleFlags
10846                 }))(obj)).Size {
10847                         {
10848                                 p := &((*(*(struct {
10849                                         ID HUDID
10850
10851                                         Field HUDField
10852
10853                                         //mt:if %s.Field == HUDPos
10854                                         Pos [2]float32
10855
10856                                         //mt:if %s.Field == HUDName
10857                                         Name string
10858
10859                                         //mt:if %s.Field == HUDScale
10860                                         Scale [2]float32
10861
10862                                         //mt:if %s.Field == HUDText
10863                                         Text string
10864
10865                                         //mt:if %s.Field == HUDNumber
10866                                         Number uint32
10867
10868                                         //mt:if %s.Field == HUDItem
10869                                         Item uint32
10870
10871                                         //mt:if %s.Field == HUDDir
10872                                         Dir uint32
10873
10874                                         //mt:if %s.Field == HUDAlign
10875                                         Align [2]float32
10876
10877                                         //mt:if %s.Field == HUDOffset
10878                                         Offset [2]float32
10879
10880                                         //mt:if %s.Field == HUDWorldPos
10881                                         WorldPos Pos
10882
10883                                         //mt:if %s.Field == HUDSize
10884                                         Size [2]int32
10885
10886                                         //mt:if %s.Field == HUDZIndex
10887                                         ZIndex int32
10888
10889                                         //mt:if %s.Field == HUDText2
10890                                         Text2 string
10891
10892                                         //mt:if %s.Field == HUDStyle
10893                                         Style HUDStyleFlags
10894                                 }))(obj)).Size)[local185]
10895                                 *p = int32(read32(r))
10896                         }
10897                 }
10898         }
10899         if (*(*(struct {
10900                 ID HUDID
10901
10902                 Field HUDField
10903
10904                 //mt:if %s.Field == HUDPos
10905                 Pos [2]float32
10906
10907                 //mt:if %s.Field == HUDName
10908                 Name string
10909
10910                 //mt:if %s.Field == HUDScale
10911                 Scale [2]float32
10912
10913                 //mt:if %s.Field == HUDText
10914                 Text string
10915
10916                 //mt:if %s.Field == HUDNumber
10917                 Number uint32
10918
10919                 //mt:if %s.Field == HUDItem
10920                 Item uint32
10921
10922                 //mt:if %s.Field == HUDDir
10923                 Dir uint32
10924
10925                 //mt:if %s.Field == HUDAlign
10926                 Align [2]float32
10927
10928                 //mt:if %s.Field == HUDOffset
10929                 Offset [2]float32
10930
10931                 //mt:if %s.Field == HUDWorldPos
10932                 WorldPos Pos
10933
10934                 //mt:if %s.Field == HUDSize
10935                 Size [2]int32
10936
10937                 //mt:if %s.Field == HUDZIndex
10938                 ZIndex int32
10939
10940                 //mt:if %s.Field == HUDText2
10941                 Text2 string
10942
10943                 //mt:if %s.Field == HUDStyle
10944                 Style HUDStyleFlags
10945         }))(obj)).Field == HUDZIndex {
10946                 {
10947                         p := &(*(*(struct {
10948                                 ID HUDID
10949
10950                                 Field HUDField
10951
10952                                 //mt:if %s.Field == HUDPos
10953                                 Pos [2]float32
10954
10955                                 //mt:if %s.Field == HUDName
10956                                 Name string
10957
10958                                 //mt:if %s.Field == HUDScale
10959                                 Scale [2]float32
10960
10961                                 //mt:if %s.Field == HUDText
10962                                 Text string
10963
10964                                 //mt:if %s.Field == HUDNumber
10965                                 Number uint32
10966
10967                                 //mt:if %s.Field == HUDItem
10968                                 Item uint32
10969
10970                                 //mt:if %s.Field == HUDDir
10971                                 Dir uint32
10972
10973                                 //mt:if %s.Field == HUDAlign
10974                                 Align [2]float32
10975
10976                                 //mt:if %s.Field == HUDOffset
10977                                 Offset [2]float32
10978
10979                                 //mt:if %s.Field == HUDWorldPos
10980                                 WorldPos Pos
10981
10982                                 //mt:if %s.Field == HUDSize
10983                                 Size [2]int32
10984
10985                                 //mt:if %s.Field == HUDZIndex
10986                                 ZIndex int32
10987
10988                                 //mt:if %s.Field == HUDText2
10989                                 Text2 string
10990
10991                                 //mt:if %s.Field == HUDStyle
10992                                 Style HUDStyleFlags
10993                         }))(obj)).ZIndex
10994                         *p = int32(read32(r))
10995                 }
10996         }
10997         if (*(*(struct {
10998                 ID HUDID
10999
11000                 Field HUDField
11001
11002                 //mt:if %s.Field == HUDPos
11003                 Pos [2]float32
11004
11005                 //mt:if %s.Field == HUDName
11006                 Name string
11007
11008                 //mt:if %s.Field == HUDScale
11009                 Scale [2]float32
11010
11011                 //mt:if %s.Field == HUDText
11012                 Text string
11013
11014                 //mt:if %s.Field == HUDNumber
11015                 Number uint32
11016
11017                 //mt:if %s.Field == HUDItem
11018                 Item uint32
11019
11020                 //mt:if %s.Field == HUDDir
11021                 Dir uint32
11022
11023                 //mt:if %s.Field == HUDAlign
11024                 Align [2]float32
11025
11026                 //mt:if %s.Field == HUDOffset
11027                 Offset [2]float32
11028
11029                 //mt:if %s.Field == HUDWorldPos
11030                 WorldPos Pos
11031
11032                 //mt:if %s.Field == HUDSize
11033                 Size [2]int32
11034
11035                 //mt:if %s.Field == HUDZIndex
11036                 ZIndex int32
11037
11038                 //mt:if %s.Field == HUDText2
11039                 Text2 string
11040
11041                 //mt:if %s.Field == HUDStyle
11042                 Style HUDStyleFlags
11043         }))(obj)).Field == HUDText2 {
11044                 var local186 []uint8
11045                 var local187 uint16
11046                 {
11047                         p := &local187
11048                         *p = read16(r)
11049                 }
11050                 (local186) = make([]uint8, local187)
11051                 {
11052                         _, err := io.ReadFull(r, (local186)[:])
11053                         chk(err)
11054                 }
11055                 ((*(*(struct {
11056                         ID HUDID
11057
11058                         Field HUDField
11059
11060                         //mt:if %s.Field == HUDPos
11061                         Pos [2]float32
11062
11063                         //mt:if %s.Field == HUDName
11064                         Name string
11065
11066                         //mt:if %s.Field == HUDScale
11067                         Scale [2]float32
11068
11069                         //mt:if %s.Field == HUDText
11070                         Text string
11071
11072                         //mt:if %s.Field == HUDNumber
11073                         Number uint32
11074
11075                         //mt:if %s.Field == HUDItem
11076                         Item uint32
11077
11078                         //mt:if %s.Field == HUDDir
11079                         Dir uint32
11080
11081                         //mt:if %s.Field == HUDAlign
11082                         Align [2]float32
11083
11084                         //mt:if %s.Field == HUDOffset
11085                         Offset [2]float32
11086
11087                         //mt:if %s.Field == HUDWorldPos
11088                         WorldPos Pos
11089
11090                         //mt:if %s.Field == HUDSize
11091                         Size [2]int32
11092
11093                         //mt:if %s.Field == HUDZIndex
11094                         ZIndex int32
11095
11096                         //mt:if %s.Field == HUDText2
11097                         Text2 string
11098
11099                         //mt:if %s.Field == HUDStyle
11100                         Style HUDStyleFlags
11101                 }))(obj)).Text2) = string(local186)
11102         }
11103         if (*(*(struct {
11104                 ID HUDID
11105
11106                 Field HUDField
11107
11108                 //mt:if %s.Field == HUDPos
11109                 Pos [2]float32
11110
11111                 //mt:if %s.Field == HUDName
11112                 Name string
11113
11114                 //mt:if %s.Field == HUDScale
11115                 Scale [2]float32
11116
11117                 //mt:if %s.Field == HUDText
11118                 Text string
11119
11120                 //mt:if %s.Field == HUDNumber
11121                 Number uint32
11122
11123                 //mt:if %s.Field == HUDItem
11124                 Item uint32
11125
11126                 //mt:if %s.Field == HUDDir
11127                 Dir uint32
11128
11129                 //mt:if %s.Field == HUDAlign
11130                 Align [2]float32
11131
11132                 //mt:if %s.Field == HUDOffset
11133                 Offset [2]float32
11134
11135                 //mt:if %s.Field == HUDWorldPos
11136                 WorldPos Pos
11137
11138                 //mt:if %s.Field == HUDSize
11139                 Size [2]int32
11140
11141                 //mt:if %s.Field == HUDZIndex
11142                 ZIndex int32
11143
11144                 //mt:if %s.Field == HUDText2
11145                 Text2 string
11146
11147                 //mt:if %s.Field == HUDStyle
11148                 Style HUDStyleFlags
11149         }))(obj)).Field == HUDStyle {
11150                 if err := pcall(func() {
11151                         ((*(*(struct {
11152                                 ID HUDID
11153
11154                                 Field HUDField
11155
11156                                 //mt:if %s.Field == HUDPos
11157                                 Pos [2]float32
11158
11159                                 //mt:if %s.Field == HUDName
11160                                 Name string
11161
11162                                 //mt:if %s.Field == HUDScale
11163                                 Scale [2]float32
11164
11165                                 //mt:if %s.Field == HUDText
11166                                 Text string
11167
11168                                 //mt:if %s.Field == HUDNumber
11169                                 Number uint32
11170
11171                                 //mt:if %s.Field == HUDItem
11172                                 Item uint32
11173
11174                                 //mt:if %s.Field == HUDDir
11175                                 Dir uint32
11176
11177                                 //mt:if %s.Field == HUDAlign
11178                                 Align [2]float32
11179
11180                                 //mt:if %s.Field == HUDOffset
11181                                 Offset [2]float32
11182
11183                                 //mt:if %s.Field == HUDWorldPos
11184                                 WorldPos Pos
11185
11186                                 //mt:if %s.Field == HUDSize
11187                                 Size [2]int32
11188
11189                                 //mt:if %s.Field == HUDZIndex
11190                                 ZIndex int32
11191
11192                                 //mt:if %s.Field == HUDText2
11193                                 Text2 string
11194
11195                                 //mt:if %s.Field == HUDStyle
11196                                 Style HUDStyleFlags
11197                         }))(obj)).Style).Deserialize(r)
11198                 }); err != nil {
11199                         if err == io.EOF {
11200                                 chk(io.EOF)
11201                         }
11202                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
11203                 }
11204         }
11205 }
11206
11207 func (obj *ToCltHUDFlags) Serialize(w io.Writer) {
11208         if err := pcall(func() {
11209                 ((*(*(struct {
11210                         // &^= Mask
11211                         // |= Flags
11212                         Flags, Mask HUDFlags
11213                 }))(obj)).Flags).Serialize(w)
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         if err := pcall(func() {
11221                 ((*(*(struct {
11222                         // &^= Mask
11223                         // |= Flags
11224                         Flags, Mask HUDFlags
11225                 }))(obj)).Mask).Serialize(w)
11226         }); err != nil {
11227                 if err == io.EOF {
11228                         chk(io.EOF)
11229                 }
11230                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11231         }
11232 }
11233
11234 func (obj *ToCltHUDFlags) Deserialize(r io.Reader) {
11235         if err := pcall(func() {
11236                 ((*(*(struct {
11237                         // &^= Mask
11238                         // |= Flags
11239                         Flags, Mask HUDFlags
11240                 }))(obj)).Flags).Deserialize(r)
11241         }); err != nil {
11242                 if err == io.EOF {
11243                         chk(io.EOF)
11244                 }
11245                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11246         }
11247         if err := pcall(func() {
11248                 ((*(*(struct {
11249                         // &^= Mask
11250                         // |= Flags
11251                         Flags, Mask HUDFlags
11252                 }))(obj)).Mask).Deserialize(r)
11253         }); err != nil {
11254                 if err == io.EOF {
11255                         chk(io.EOF)
11256                 }
11257                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11258         }
11259 }
11260
11261 func (obj *ToCltSetHotbarParam) Serialize(w io.Writer) {
11262         if err := pcall(func() {
11263                 ((*(*(struct {
11264                         Param HotbarParam
11265
11266                         //mt:if %s.Param == HotbarSize
11267                         //mt:const uint16(4) // Size of Size field.
11268                         Size int32
11269
11270                         //mt:if %s.Param != HotbarSize
11271                         Img Texture
11272                 }))(obj)).Param).Serialize(w)
11273         }); err != nil {
11274                 if err == io.EOF {
11275                         chk(io.EOF)
11276                 }
11277                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HotbarParam", err))
11278         }
11279         if (*(*(struct {
11280                 Param HotbarParam
11281
11282                 //mt:if %s.Param == HotbarSize
11283                 //mt:const uint16(4) // Size of Size field.
11284                 Size int32
11285
11286                 //mt:if %s.Param != HotbarSize
11287                 Img Texture
11288         }))(obj)).Param == HotbarSize {
11289                 {
11290                         local188 := uint16(4) // Size of Size field.
11291                         {
11292                                 x := local188
11293                                 write16(w, uint16(x))
11294                         }
11295                 }
11296                 {
11297                         x := (*(*(struct {
11298                                 Param HotbarParam
11299
11300                                 //mt:if %s.Param == HotbarSize
11301                                 //mt:const uint16(4) // Size of Size field.
11302                                 Size int32
11303
11304                                 //mt:if %s.Param != HotbarSize
11305                                 Img Texture
11306                         }))(obj)).Size
11307                         write32(w, uint32(x))
11308                 }
11309         }
11310         if (*(*(struct {
11311                 Param HotbarParam
11312
11313                 //mt:if %s.Param == HotbarSize
11314                 //mt:const uint16(4) // Size of Size field.
11315                 Size int32
11316
11317                 //mt:if %s.Param != HotbarSize
11318                 Img Texture
11319         }))(obj)).Param != HotbarSize {
11320                 if err := pcall(func() {
11321                         ((*(*(struct {
11322                                 Param HotbarParam
11323
11324                                 //mt:if %s.Param == HotbarSize
11325                                 //mt:const uint16(4) // Size of Size field.
11326                                 Size int32
11327
11328                                 //mt:if %s.Param != HotbarSize
11329                                 Img Texture
11330                         }))(obj)).Img).Serialize(w)
11331                 }); err != nil {
11332                         if err == io.EOF {
11333                                 chk(io.EOF)
11334                         }
11335                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11336                 }
11337         }
11338 }
11339
11340 func (obj *ToCltSetHotbarParam) Deserialize(r io.Reader) {
11341         if err := pcall(func() {
11342                 ((*(*(struct {
11343                         Param HotbarParam
11344
11345                         //mt:if %s.Param == HotbarSize
11346                         //mt:const uint16(4) // Size of Size field.
11347                         Size int32
11348
11349                         //mt:if %s.Param != HotbarSize
11350                         Img Texture
11351                 }))(obj)).Param).Deserialize(r)
11352         }); err != nil {
11353                 if err == io.EOF {
11354                         chk(io.EOF)
11355                 }
11356                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HotbarParam", err))
11357         }
11358         if (*(*(struct {
11359                 Param HotbarParam
11360
11361                 //mt:if %s.Param == HotbarSize
11362                 //mt:const uint16(4) // Size of Size field.
11363                 Size int32
11364
11365                 //mt:if %s.Param != HotbarSize
11366                 Img Texture
11367         }))(obj)).Param == HotbarSize {
11368                 {
11369                         var local189 uint16
11370                         local190 := uint16(4) // Size of Size field.
11371                         {
11372                                 p := &local189
11373                                 *p = read16(r)
11374                         }
11375                         if local189 != local190 {
11376                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local189))
11377                         }
11378                 }
11379                 {
11380                         p := &(*(*(struct {
11381                                 Param HotbarParam
11382
11383                                 //mt:if %s.Param == HotbarSize
11384                                 //mt:const uint16(4) // Size of Size field.
11385                                 Size int32
11386
11387                                 //mt:if %s.Param != HotbarSize
11388                                 Img Texture
11389                         }))(obj)).Size
11390                         *p = int32(read32(r))
11391                 }
11392         }
11393         if (*(*(struct {
11394                 Param HotbarParam
11395
11396                 //mt:if %s.Param == HotbarSize
11397                 //mt:const uint16(4) // Size of Size field.
11398                 Size int32
11399
11400                 //mt:if %s.Param != HotbarSize
11401                 Img Texture
11402         }))(obj)).Param != HotbarSize {
11403                 if err := pcall(func() {
11404                         ((*(*(struct {
11405                                 Param HotbarParam
11406
11407                                 //mt:if %s.Param == HotbarSize
11408                                 //mt:const uint16(4) // Size of Size field.
11409                                 Size int32
11410
11411                                 //mt:if %s.Param != HotbarSize
11412                                 Img Texture
11413                         }))(obj)).Img).Deserialize(r)
11414                 }); err != nil {
11415                         if err == io.EOF {
11416                                 chk(io.EOF)
11417                         }
11418                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11419                 }
11420         }
11421 }
11422
11423 func (obj *ToCltBreath) Serialize(w io.Writer) {
11424         {
11425                 x := (*(*(struct {
11426                         Breath uint16
11427                 }))(obj)).Breath
11428                 write16(w, uint16(x))
11429         }
11430 }
11431
11432 func (obj *ToCltBreath) Deserialize(r io.Reader) {
11433         {
11434                 p := &(*(*(struct {
11435                         Breath uint16
11436                 }))(obj)).Breath
11437                 *p = read16(r)
11438         }
11439 }
11440
11441 func (obj *ToCltSkyParams) Serialize(w io.Writer) {
11442         {
11443                 x := (*(*(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)).BgColor
11460                 w.Write([]byte{x.A, x.R, x.G, x.B})
11461         }
11462         if len(([]byte((*(*(struct {
11463                 BgColor     color.NRGBA
11464                 Type        string
11465                 Clouds      bool
11466                 SunFogTint  color.NRGBA
11467                 MoonFogTint color.NRGBA
11468                 FogTintType string
11469
11470                 //mt:if %s.Type == "skybox"
11471                 Textures []Texture
11472
11473                 //mt:if %s.Type == "regular"
11474                 DaySky, DayHorizon,
11475                 DawnSky, DawnHorizon,
11476                 NightSky, NightHorizon,
11477                 Indoor color.NRGBA
11478         }))(obj)).Type))) > math.MaxUint16 {
11479                 chk(ErrTooLong)
11480         }
11481         {
11482                 x := uint16(len(([]byte((*(*(struct {
11483                         BgColor     color.NRGBA
11484                         Type        string
11485                         Clouds      bool
11486                         SunFogTint  color.NRGBA
11487                         MoonFogTint color.NRGBA
11488                         FogTintType string
11489
11490                         //mt:if %s.Type == "skybox"
11491                         Textures []Texture
11492
11493                         //mt:if %s.Type == "regular"
11494                         DaySky, DayHorizon,
11495                         DawnSky, DawnHorizon,
11496                         NightSky, NightHorizon,
11497                         Indoor color.NRGBA
11498                 }))(obj)).Type))))
11499                 write16(w, uint16(x))
11500         }
11501         {
11502                 _, err := w.Write(([]byte((*(*(struct {
11503                         BgColor     color.NRGBA
11504                         Type        string
11505                         Clouds      bool
11506                         SunFogTint  color.NRGBA
11507                         MoonFogTint color.NRGBA
11508                         FogTintType string
11509
11510                         //mt:if %s.Type == "skybox"
11511                         Textures []Texture
11512
11513                         //mt:if %s.Type == "regular"
11514                         DaySky, DayHorizon,
11515                         DawnSky, DawnHorizon,
11516                         NightSky, NightHorizon,
11517                         Indoor color.NRGBA
11518                 }))(obj)).Type))[:])
11519                 chk(err)
11520         }
11521         {
11522                 x := (*(*(struct {
11523                         BgColor     color.NRGBA
11524                         Type        string
11525                         Clouds      bool
11526                         SunFogTint  color.NRGBA
11527                         MoonFogTint color.NRGBA
11528                         FogTintType string
11529
11530                         //mt:if %s.Type == "skybox"
11531                         Textures []Texture
11532
11533                         //mt:if %s.Type == "regular"
11534                         DaySky, DayHorizon,
11535                         DawnSky, DawnHorizon,
11536                         NightSky, NightHorizon,
11537                         Indoor color.NRGBA
11538                 }))(obj)).Clouds
11539                 if x {
11540                         write8(w, 1)
11541                 } else {
11542                         write8(w, 0)
11543                 }
11544         }
11545         {
11546                 x := (*(*(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)).SunFogTint
11563                 w.Write([]byte{x.A, x.R, x.G, x.B})
11564         }
11565         {
11566                 x := (*(*(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)).MoonFogTint
11583                 w.Write([]byte{x.A, x.R, x.G, x.B})
11584         }
11585         if len(([]byte((*(*(struct {
11586                 BgColor     color.NRGBA
11587                 Type        string
11588                 Clouds      bool
11589                 SunFogTint  color.NRGBA
11590                 MoonFogTint color.NRGBA
11591                 FogTintType string
11592
11593                 //mt:if %s.Type == "skybox"
11594                 Textures []Texture
11595
11596                 //mt:if %s.Type == "regular"
11597                 DaySky, DayHorizon,
11598                 DawnSky, DawnHorizon,
11599                 NightSky, NightHorizon,
11600                 Indoor color.NRGBA
11601         }))(obj)).FogTintType))) > math.MaxUint16 {
11602                 chk(ErrTooLong)
11603         }
11604         {
11605                 x := uint16(len(([]byte((*(*(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)).FogTintType))))
11622                 write16(w, uint16(x))
11623         }
11624         {
11625                 _, err := w.Write(([]byte((*(*(struct {
11626                         BgColor     color.NRGBA
11627                         Type        string
11628                         Clouds      bool
11629                         SunFogTint  color.NRGBA
11630                         MoonFogTint color.NRGBA
11631                         FogTintType string
11632
11633                         //mt:if %s.Type == "skybox"
11634                         Textures []Texture
11635
11636                         //mt:if %s.Type == "regular"
11637                         DaySky, DayHorizon,
11638                         DawnSky, DawnHorizon,
11639                         NightSky, NightHorizon,
11640                         Indoor color.NRGBA
11641                 }))(obj)).FogTintType))[:])
11642                 chk(err)
11643         }
11644         if (*(*(struct {
11645                 BgColor     color.NRGBA
11646                 Type        string
11647                 Clouds      bool
11648                 SunFogTint  color.NRGBA
11649                 MoonFogTint color.NRGBA
11650                 FogTintType string
11651
11652                 //mt:if %s.Type == "skybox"
11653                 Textures []Texture
11654
11655                 //mt:if %s.Type == "regular"
11656                 DaySky, DayHorizon,
11657                 DawnSky, DawnHorizon,
11658                 NightSky, NightHorizon,
11659                 Indoor color.NRGBA
11660         }))(obj)).Type == "skybox" {
11661                 if len(((*(*(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)) > math.MaxUint16 {
11678                         chk(ErrTooLong)
11679                 }
11680                 {
11681                         x := uint16(len(((*(*(struct {
11682                                 BgColor     color.NRGBA
11683                                 Type        string
11684                                 Clouds      bool
11685                                 SunFogTint  color.NRGBA
11686                                 MoonFogTint color.NRGBA
11687                                 FogTintType string
11688
11689                                 //mt:if %s.Type == "skybox"
11690                                 Textures []Texture
11691
11692                                 //mt:if %s.Type == "regular"
11693                                 DaySky, DayHorizon,
11694                                 DawnSky, DawnHorizon,
11695                                 NightSky, NightHorizon,
11696                                 Indoor color.NRGBA
11697                         }))(obj)).Textures)))
11698                         write16(w, uint16(x))
11699                 }
11700                 for local191 := range (*(*(struct {
11701                         BgColor     color.NRGBA
11702                         Type        string
11703                         Clouds      bool
11704                         SunFogTint  color.NRGBA
11705                         MoonFogTint color.NRGBA
11706                         FogTintType string
11707
11708                         //mt:if %s.Type == "skybox"
11709                         Textures []Texture
11710
11711                         //mt:if %s.Type == "regular"
11712                         DaySky, DayHorizon,
11713                         DawnSky, DawnHorizon,
11714                         NightSky, NightHorizon,
11715                         Indoor color.NRGBA
11716                 }))(obj)).Textures {
11717                         if err := pcall(func() {
11718                                 (((*(*(struct {
11719                                         BgColor     color.NRGBA
11720                                         Type        string
11721                                         Clouds      bool
11722                                         SunFogTint  color.NRGBA
11723                                         MoonFogTint color.NRGBA
11724                                         FogTintType string
11725
11726                                         //mt:if %s.Type == "skybox"
11727                                         Textures []Texture
11728
11729                                         //mt:if %s.Type == "regular"
11730                                         DaySky, DayHorizon,
11731                                         DawnSky, DawnHorizon,
11732                                         NightSky, NightHorizon,
11733                                         Indoor color.NRGBA
11734                                 }))(obj)).Textures)[local191]).Serialize(w)
11735                         }); err != nil {
11736                                 if err == io.EOF {
11737                                         chk(io.EOF)
11738                                 }
11739                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11740                         }
11741                 }
11742         }
11743         if (*(*(struct {
11744                 BgColor     color.NRGBA
11745                 Type        string
11746                 Clouds      bool
11747                 SunFogTint  color.NRGBA
11748                 MoonFogTint color.NRGBA
11749                 FogTintType string
11750
11751                 //mt:if %s.Type == "skybox"
11752                 Textures []Texture
11753
11754                 //mt:if %s.Type == "regular"
11755                 DaySky, DayHorizon,
11756                 DawnSky, DawnHorizon,
11757                 NightSky, NightHorizon,
11758                 Indoor color.NRGBA
11759         }))(obj)).Type == "regular" {
11760                 {
11761                         x := (*(*(struct {
11762                                 BgColor     color.NRGBA
11763                                 Type        string
11764                                 Clouds      bool
11765                                 SunFogTint  color.NRGBA
11766                                 MoonFogTint color.NRGBA
11767                                 FogTintType string
11768
11769                                 //mt:if %s.Type == "skybox"
11770                                 Textures []Texture
11771
11772                                 //mt:if %s.Type == "regular"
11773                                 DaySky, DayHorizon,
11774                                 DawnSky, DawnHorizon,
11775                                 NightSky, NightHorizon,
11776                                 Indoor color.NRGBA
11777                         }))(obj)).DaySky
11778                         w.Write([]byte{x.A, x.R, x.G, x.B})
11779                 }
11780                 {
11781                         x := (*(*(struct {
11782                                 BgColor     color.NRGBA
11783                                 Type        string
11784                                 Clouds      bool
11785                                 SunFogTint  color.NRGBA
11786                                 MoonFogTint color.NRGBA
11787                                 FogTintType string
11788
11789                                 //mt:if %s.Type == "skybox"
11790                                 Textures []Texture
11791
11792                                 //mt:if %s.Type == "regular"
11793                                 DaySky, DayHorizon,
11794                                 DawnSky, DawnHorizon,
11795                                 NightSky, NightHorizon,
11796                                 Indoor color.NRGBA
11797                         }))(obj)).DayHorizon
11798                         w.Write([]byte{x.A, x.R, x.G, x.B})
11799                 }
11800                 {
11801                         x := (*(*(struct {
11802                                 BgColor     color.NRGBA
11803                                 Type        string
11804                                 Clouds      bool
11805                                 SunFogTint  color.NRGBA
11806                                 MoonFogTint color.NRGBA
11807                                 FogTintType string
11808
11809                                 //mt:if %s.Type == "skybox"
11810                                 Textures []Texture
11811
11812                                 //mt:if %s.Type == "regular"
11813                                 DaySky, DayHorizon,
11814                                 DawnSky, DawnHorizon,
11815                                 NightSky, NightHorizon,
11816                                 Indoor color.NRGBA
11817                         }))(obj)).DawnSky
11818                         w.Write([]byte{x.A, x.R, x.G, x.B})
11819                 }
11820                 {
11821                         x := (*(*(struct {
11822                                 BgColor     color.NRGBA
11823                                 Type        string
11824                                 Clouds      bool
11825                                 SunFogTint  color.NRGBA
11826                                 MoonFogTint color.NRGBA
11827                                 FogTintType string
11828
11829                                 //mt:if %s.Type == "skybox"
11830                                 Textures []Texture
11831
11832                                 //mt:if %s.Type == "regular"
11833                                 DaySky, DayHorizon,
11834                                 DawnSky, DawnHorizon,
11835                                 NightSky, NightHorizon,
11836                                 Indoor color.NRGBA
11837                         }))(obj)).DawnHorizon
11838                         w.Write([]byte{x.A, x.R, x.G, x.B})
11839                 }
11840                 {
11841                         x := (*(*(struct {
11842                                 BgColor     color.NRGBA
11843                                 Type        string
11844                                 Clouds      bool
11845                                 SunFogTint  color.NRGBA
11846                                 MoonFogTint color.NRGBA
11847                                 FogTintType string
11848
11849                                 //mt:if %s.Type == "skybox"
11850                                 Textures []Texture
11851
11852                                 //mt:if %s.Type == "regular"
11853                                 DaySky, DayHorizon,
11854                                 DawnSky, DawnHorizon,
11855                                 NightSky, NightHorizon,
11856                                 Indoor color.NRGBA
11857                         }))(obj)).NightSky
11858                         w.Write([]byte{x.A, x.R, x.G, x.B})
11859                 }
11860                 {
11861                         x := (*(*(struct {
11862                                 BgColor     color.NRGBA
11863                                 Type        string
11864                                 Clouds      bool
11865                                 SunFogTint  color.NRGBA
11866                                 MoonFogTint color.NRGBA
11867                                 FogTintType string
11868
11869                                 //mt:if %s.Type == "skybox"
11870                                 Textures []Texture
11871
11872                                 //mt:if %s.Type == "regular"
11873                                 DaySky, DayHorizon,
11874                                 DawnSky, DawnHorizon,
11875                                 NightSky, NightHorizon,
11876                                 Indoor color.NRGBA
11877                         }))(obj)).NightHorizon
11878                         w.Write([]byte{x.A, x.R, x.G, x.B})
11879                 }
11880                 {
11881                         x := (*(*(struct {
11882                                 BgColor     color.NRGBA
11883                                 Type        string
11884                                 Clouds      bool
11885                                 SunFogTint  color.NRGBA
11886                                 MoonFogTint color.NRGBA
11887                                 FogTintType string
11888
11889                                 //mt:if %s.Type == "skybox"
11890                                 Textures []Texture
11891
11892                                 //mt:if %s.Type == "regular"
11893                                 DaySky, DayHorizon,
11894                                 DawnSky, DawnHorizon,
11895                                 NightSky, NightHorizon,
11896                                 Indoor color.NRGBA
11897                         }))(obj)).Indoor
11898                         w.Write([]byte{x.A, x.R, x.G, x.B})
11899                 }
11900         }
11901 }
11902
11903 func (obj *ToCltSkyParams) Deserialize(r io.Reader) {
11904         {
11905                 p := &(*(*(struct {
11906                         BgColor     color.NRGBA
11907                         Type        string
11908                         Clouds      bool
11909                         SunFogTint  color.NRGBA
11910                         MoonFogTint color.NRGBA
11911                         FogTintType string
11912
11913                         //mt:if %s.Type == "skybox"
11914                         Textures []Texture
11915
11916                         //mt:if %s.Type == "regular"
11917                         DaySky, DayHorizon,
11918                         DawnSky, DawnHorizon,
11919                         NightSky, NightHorizon,
11920                         Indoor color.NRGBA
11921                 }))(obj)).BgColor
11922                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11923         }
11924         var local192 []uint8
11925         var local193 uint16
11926         {
11927                 p := &local193
11928                 *p = read16(r)
11929         }
11930         (local192) = make([]uint8, local193)
11931         {
11932                 _, err := io.ReadFull(r, (local192)[:])
11933                 chk(err)
11934         }
11935         ((*(*(struct {
11936                 BgColor     color.NRGBA
11937                 Type        string
11938                 Clouds      bool
11939                 SunFogTint  color.NRGBA
11940                 MoonFogTint color.NRGBA
11941                 FogTintType string
11942
11943                 //mt:if %s.Type == "skybox"
11944                 Textures []Texture
11945
11946                 //mt:if %s.Type == "regular"
11947                 DaySky, DayHorizon,
11948                 DawnSky, DawnHorizon,
11949                 NightSky, NightHorizon,
11950                 Indoor color.NRGBA
11951         }))(obj)).Type) = string(local192)
11952         {
11953                 p := &(*(*(struct {
11954                         BgColor     color.NRGBA
11955                         Type        string
11956                         Clouds      bool
11957                         SunFogTint  color.NRGBA
11958                         MoonFogTint color.NRGBA
11959                         FogTintType string
11960
11961                         //mt:if %s.Type == "skybox"
11962                         Textures []Texture
11963
11964                         //mt:if %s.Type == "regular"
11965                         DaySky, DayHorizon,
11966                         DawnSky, DawnHorizon,
11967                         NightSky, NightHorizon,
11968                         Indoor color.NRGBA
11969                 }))(obj)).Clouds
11970                 switch n := read8(r); n {
11971                 case 0:
11972                         *p = false
11973                 case 1:
11974                         *p = true
11975                 default:
11976                         chk(fmt.Errorf("invalid bool: %d", n))
11977                 }
11978         }
11979         {
11980                 p := &(*(*(struct {
11981                         BgColor     color.NRGBA
11982                         Type        string
11983                         Clouds      bool
11984                         SunFogTint  color.NRGBA
11985                         MoonFogTint color.NRGBA
11986                         FogTintType string
11987
11988                         //mt:if %s.Type == "skybox"
11989                         Textures []Texture
11990
11991                         //mt:if %s.Type == "regular"
11992                         DaySky, DayHorizon,
11993                         DawnSky, DawnHorizon,
11994                         NightSky, NightHorizon,
11995                         Indoor color.NRGBA
11996                 }))(obj)).SunFogTint
11997                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11998         }
11999         {
12000                 p := &(*(*(struct {
12001                         BgColor     color.NRGBA
12002                         Type        string
12003                         Clouds      bool
12004                         SunFogTint  color.NRGBA
12005                         MoonFogTint color.NRGBA
12006                         FogTintType string
12007
12008                         //mt:if %s.Type == "skybox"
12009                         Textures []Texture
12010
12011                         //mt:if %s.Type == "regular"
12012                         DaySky, DayHorizon,
12013                         DawnSky, DawnHorizon,
12014                         NightSky, NightHorizon,
12015                         Indoor color.NRGBA
12016                 }))(obj)).MoonFogTint
12017                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12018         }
12019         var local194 []uint8
12020         var local195 uint16
12021         {
12022                 p := &local195
12023                 *p = read16(r)
12024         }
12025         (local194) = make([]uint8, local195)
12026         {
12027                 _, err := io.ReadFull(r, (local194)[:])
12028                 chk(err)
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)).FogTintType) = string(local194)
12047         if (*(*(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)).Type == "skybox" {
12064                 var local196 uint16
12065                 {
12066                         p := &local196
12067                         *p = read16(r)
12068                 }
12069                 ((*(*(struct {
12070                         BgColor     color.NRGBA
12071                         Type        string
12072                         Clouds      bool
12073                         SunFogTint  color.NRGBA
12074                         MoonFogTint color.NRGBA
12075                         FogTintType string
12076
12077                         //mt:if %s.Type == "skybox"
12078                         Textures []Texture
12079
12080                         //mt:if %s.Type == "regular"
12081                         DaySky, DayHorizon,
12082                         DawnSky, DawnHorizon,
12083                         NightSky, NightHorizon,
12084                         Indoor color.NRGBA
12085                 }))(obj)).Textures) = make([]Texture, local196)
12086                 for local197 := range (*(*(struct {
12087                         BgColor     color.NRGBA
12088                         Type        string
12089                         Clouds      bool
12090                         SunFogTint  color.NRGBA
12091                         MoonFogTint color.NRGBA
12092                         FogTintType string
12093
12094                         //mt:if %s.Type == "skybox"
12095                         Textures []Texture
12096
12097                         //mt:if %s.Type == "regular"
12098                         DaySky, DayHorizon,
12099                         DawnSky, DawnHorizon,
12100                         NightSky, NightHorizon,
12101                         Indoor color.NRGBA
12102                 }))(obj)).Textures {
12103                         if err := pcall(func() {
12104                                 (((*(*(struct {
12105                                         BgColor     color.NRGBA
12106                                         Type        string
12107                                         Clouds      bool
12108                                         SunFogTint  color.NRGBA
12109                                         MoonFogTint color.NRGBA
12110                                         FogTintType string
12111
12112                                         //mt:if %s.Type == "skybox"
12113                                         Textures []Texture
12114
12115                                         //mt:if %s.Type == "regular"
12116                                         DaySky, DayHorizon,
12117                                         DawnSky, DawnHorizon,
12118                                         NightSky, NightHorizon,
12119                                         Indoor color.NRGBA
12120                                 }))(obj)).Textures)[local197]).Deserialize(r)
12121                         }); err != nil {
12122                                 if err == io.EOF {
12123                                         chk(io.EOF)
12124                                 }
12125                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
12126                         }
12127                 }
12128         }
12129         if (*(*(struct {
12130                 BgColor     color.NRGBA
12131                 Type        string
12132                 Clouds      bool
12133                 SunFogTint  color.NRGBA
12134                 MoonFogTint color.NRGBA
12135                 FogTintType string
12136
12137                 //mt:if %s.Type == "skybox"
12138                 Textures []Texture
12139
12140                 //mt:if %s.Type == "regular"
12141                 DaySky, DayHorizon,
12142                 DawnSky, DawnHorizon,
12143                 NightSky, NightHorizon,
12144                 Indoor color.NRGBA
12145         }))(obj)).Type == "regular" {
12146                 {
12147                         p := &(*(*(struct {
12148                                 BgColor     color.NRGBA
12149                                 Type        string
12150                                 Clouds      bool
12151                                 SunFogTint  color.NRGBA
12152                                 MoonFogTint color.NRGBA
12153                                 FogTintType string
12154
12155                                 //mt:if %s.Type == "skybox"
12156                                 Textures []Texture
12157
12158                                 //mt:if %s.Type == "regular"
12159                                 DaySky, DayHorizon,
12160                                 DawnSky, DawnHorizon,
12161                                 NightSky, NightHorizon,
12162                                 Indoor color.NRGBA
12163                         }))(obj)).DaySky
12164                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12165                 }
12166                 {
12167                         p := &(*(*(struct {
12168                                 BgColor     color.NRGBA
12169                                 Type        string
12170                                 Clouds      bool
12171                                 SunFogTint  color.NRGBA
12172                                 MoonFogTint color.NRGBA
12173                                 FogTintType string
12174
12175                                 //mt:if %s.Type == "skybox"
12176                                 Textures []Texture
12177
12178                                 //mt:if %s.Type == "regular"
12179                                 DaySky, DayHorizon,
12180                                 DawnSky, DawnHorizon,
12181                                 NightSky, NightHorizon,
12182                                 Indoor color.NRGBA
12183                         }))(obj)).DayHorizon
12184                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12185                 }
12186                 {
12187                         p := &(*(*(struct {
12188                                 BgColor     color.NRGBA
12189                                 Type        string
12190                                 Clouds      bool
12191                                 SunFogTint  color.NRGBA
12192                                 MoonFogTint color.NRGBA
12193                                 FogTintType string
12194
12195                                 //mt:if %s.Type == "skybox"
12196                                 Textures []Texture
12197
12198                                 //mt:if %s.Type == "regular"
12199                                 DaySky, DayHorizon,
12200                                 DawnSky, DawnHorizon,
12201                                 NightSky, NightHorizon,
12202                                 Indoor color.NRGBA
12203                         }))(obj)).DawnSky
12204                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12205                 }
12206                 {
12207                         p := &(*(*(struct {
12208                                 BgColor     color.NRGBA
12209                                 Type        string
12210                                 Clouds      bool
12211                                 SunFogTint  color.NRGBA
12212                                 MoonFogTint color.NRGBA
12213                                 FogTintType string
12214
12215                                 //mt:if %s.Type == "skybox"
12216                                 Textures []Texture
12217
12218                                 //mt:if %s.Type == "regular"
12219                                 DaySky, DayHorizon,
12220                                 DawnSky, DawnHorizon,
12221                                 NightSky, NightHorizon,
12222                                 Indoor color.NRGBA
12223                         }))(obj)).DawnHorizon
12224                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12225                 }
12226                 {
12227                         p := &(*(*(struct {
12228                                 BgColor     color.NRGBA
12229                                 Type        string
12230                                 Clouds      bool
12231                                 SunFogTint  color.NRGBA
12232                                 MoonFogTint color.NRGBA
12233                                 FogTintType string
12234
12235                                 //mt:if %s.Type == "skybox"
12236                                 Textures []Texture
12237
12238                                 //mt:if %s.Type == "regular"
12239                                 DaySky, DayHorizon,
12240                                 DawnSky, DawnHorizon,
12241                                 NightSky, NightHorizon,
12242                                 Indoor color.NRGBA
12243                         }))(obj)).NightSky
12244                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12245                 }
12246                 {
12247                         p := &(*(*(struct {
12248                                 BgColor     color.NRGBA
12249                                 Type        string
12250                                 Clouds      bool
12251                                 SunFogTint  color.NRGBA
12252                                 MoonFogTint color.NRGBA
12253                                 FogTintType string
12254
12255                                 //mt:if %s.Type == "skybox"
12256                                 Textures []Texture
12257
12258                                 //mt:if %s.Type == "regular"
12259                                 DaySky, DayHorizon,
12260                                 DawnSky, DawnHorizon,
12261                                 NightSky, NightHorizon,
12262                                 Indoor color.NRGBA
12263                         }))(obj)).NightHorizon
12264                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12265                 }
12266                 {
12267                         p := &(*(*(struct {
12268                                 BgColor     color.NRGBA
12269                                 Type        string
12270                                 Clouds      bool
12271                                 SunFogTint  color.NRGBA
12272                                 MoonFogTint color.NRGBA
12273                                 FogTintType string
12274
12275                                 //mt:if %s.Type == "skybox"
12276                                 Textures []Texture
12277
12278                                 //mt:if %s.Type == "regular"
12279                                 DaySky, DayHorizon,
12280                                 DawnSky, DawnHorizon,
12281                                 NightSky, NightHorizon,
12282                                 Indoor color.NRGBA
12283                         }))(obj)).Indoor
12284                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12285                 }
12286         }
12287 }
12288
12289 func (obj *ToCltOverrideDayNightRatio) Serialize(w io.Writer) {
12290         {
12291                 x := (*(*(struct {
12292                         Override bool
12293                         Ratio    uint16
12294                 }))(obj)).Override
12295                 if x {
12296                         write8(w, 1)
12297                 } else {
12298                         write8(w, 0)
12299                 }
12300         }
12301         {
12302                 x := (*(*(struct {
12303                         Override bool
12304                         Ratio    uint16
12305                 }))(obj)).Ratio
12306                 write16(w, uint16(x))
12307         }
12308 }
12309
12310 func (obj *ToCltOverrideDayNightRatio) Deserialize(r io.Reader) {
12311         {
12312                 p := &(*(*(struct {
12313                         Override bool
12314                         Ratio    uint16
12315                 }))(obj)).Override
12316                 switch n := read8(r); n {
12317                 case 0:
12318                         *p = false
12319                 case 1:
12320                         *p = true
12321                 default:
12322                         chk(fmt.Errorf("invalid bool: %d", n))
12323                 }
12324         }
12325         {
12326                 p := &(*(*(struct {
12327                         Override bool
12328                         Ratio    uint16
12329                 }))(obj)).Ratio
12330                 *p = read16(r)
12331         }
12332 }
12333
12334 func (obj *ToCltLocalPlayerAnim) Serialize(w io.Writer) {
12335         for local198 := range (*(*(struct {
12336                 Idle, Walk, Dig, WalkDig [2]int32
12337                 Speed                    float32
12338         }))(obj)).Idle {
12339                 {
12340                         x := ((*(*(struct {
12341                                 Idle, Walk, Dig, WalkDig [2]int32
12342                                 Speed                    float32
12343                         }))(obj)).Idle)[local198]
12344                         write32(w, uint32(x))
12345                 }
12346         }
12347         for local199 := range (*(*(struct {
12348                 Idle, Walk, Dig, WalkDig [2]int32
12349                 Speed                    float32
12350         }))(obj)).Walk {
12351                 {
12352                         x := ((*(*(struct {
12353                                 Idle, Walk, Dig, WalkDig [2]int32
12354                                 Speed                    float32
12355                         }))(obj)).Walk)[local199]
12356                         write32(w, uint32(x))
12357                 }
12358         }
12359         for local200 := range (*(*(struct {
12360                 Idle, Walk, Dig, WalkDig [2]int32
12361                 Speed                    float32
12362         }))(obj)).Dig {
12363                 {
12364                         x := ((*(*(struct {
12365                                 Idle, Walk, Dig, WalkDig [2]int32
12366                                 Speed                    float32
12367                         }))(obj)).Dig)[local200]
12368                         write32(w, uint32(x))
12369                 }
12370         }
12371         for local201 := range (*(*(struct {
12372                 Idle, Walk, Dig, WalkDig [2]int32
12373                 Speed                    float32
12374         }))(obj)).WalkDig {
12375                 {
12376                         x := ((*(*(struct {
12377                                 Idle, Walk, Dig, WalkDig [2]int32
12378                                 Speed                    float32
12379                         }))(obj)).WalkDig)[local201]
12380                         write32(w, uint32(x))
12381                 }
12382         }
12383         {
12384                 x := (*(*(struct {
12385                         Idle, Walk, Dig, WalkDig [2]int32
12386                         Speed                    float32
12387                 }))(obj)).Speed
12388                 write32(w, math.Float32bits(x))
12389         }
12390 }
12391
12392 func (obj *ToCltLocalPlayerAnim) Deserialize(r io.Reader) {
12393         for local202 := range (*(*(struct {
12394                 Idle, Walk, Dig, WalkDig [2]int32
12395                 Speed                    float32
12396         }))(obj)).Idle {
12397                 {
12398                         p := &((*(*(struct {
12399                                 Idle, Walk, Dig, WalkDig [2]int32
12400                                 Speed                    float32
12401                         }))(obj)).Idle)[local202]
12402                         *p = int32(read32(r))
12403                 }
12404         }
12405         for local203 := range (*(*(struct {
12406                 Idle, Walk, Dig, WalkDig [2]int32
12407                 Speed                    float32
12408         }))(obj)).Walk {
12409                 {
12410                         p := &((*(*(struct {
12411                                 Idle, Walk, Dig, WalkDig [2]int32
12412                                 Speed                    float32
12413                         }))(obj)).Walk)[local203]
12414                         *p = int32(read32(r))
12415                 }
12416         }
12417         for local204 := range (*(*(struct {
12418                 Idle, Walk, Dig, WalkDig [2]int32
12419                 Speed                    float32
12420         }))(obj)).Dig {
12421                 {
12422                         p := &((*(*(struct {
12423                                 Idle, Walk, Dig, WalkDig [2]int32
12424                                 Speed                    float32
12425                         }))(obj)).Dig)[local204]
12426                         *p = int32(read32(r))
12427                 }
12428         }
12429         for local205 := range (*(*(struct {
12430                 Idle, Walk, Dig, WalkDig [2]int32
12431                 Speed                    float32
12432         }))(obj)).WalkDig {
12433                 {
12434                         p := &((*(*(struct {
12435                                 Idle, Walk, Dig, WalkDig [2]int32
12436                                 Speed                    float32
12437                         }))(obj)).WalkDig)[local205]
12438                         *p = int32(read32(r))
12439                 }
12440         }
12441         {
12442                 p := &(*(*(struct {
12443                         Idle, Walk, Dig, WalkDig [2]int32
12444                         Speed                    float32
12445                 }))(obj)).Speed
12446                 *p = math.Float32frombits(read32(r))
12447         }
12448 }
12449
12450 func (obj *ToCltEyeOffset) Serialize(w io.Writer) {
12451         if err := pcall(func() {
12452                 ((*(*(struct {
12453                         First, Third Vec
12454                 }))(obj)).First).Serialize(w)
12455         }); err != nil {
12456                 if err == io.EOF {
12457                         chk(io.EOF)
12458                 }
12459                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12460         }
12461         if err := pcall(func() {
12462                 ((*(*(struct {
12463                         First, Third Vec
12464                 }))(obj)).Third).Serialize(w)
12465         }); err != nil {
12466                 if err == io.EOF {
12467                         chk(io.EOF)
12468                 }
12469                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12470         }
12471 }
12472
12473 func (obj *ToCltEyeOffset) Deserialize(r io.Reader) {
12474         if err := pcall(func() {
12475                 ((*(*(struct {
12476                         First, Third Vec
12477                 }))(obj)).First).Deserialize(r)
12478         }); err != nil {
12479                 if err == io.EOF {
12480                         chk(io.EOF)
12481                 }
12482                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12483         }
12484         if err := pcall(func() {
12485                 ((*(*(struct {
12486                         First, Third Vec
12487                 }))(obj)).Third).Deserialize(r)
12488         }); err != nil {
12489                 if err == io.EOF {
12490                         chk(io.EOF)
12491                 }
12492                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12493         }
12494 }
12495
12496 func (obj *ToCltDelParticleSpawner) Serialize(w io.Writer) {
12497         if err := pcall(func() {
12498                 ((*(*(struct {
12499                         ID ParticleSpawnerID
12500                 }))(obj)).ID).Serialize(w)
12501         }); err != nil {
12502                 if err == io.EOF {
12503                         chk(io.EOF)
12504                 }
12505                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
12506         }
12507 }
12508
12509 func (obj *ToCltDelParticleSpawner) Deserialize(r io.Reader) {
12510         if err := pcall(func() {
12511                 ((*(*(struct {
12512                         ID ParticleSpawnerID
12513                 }))(obj)).ID).Deserialize(r)
12514         }); err != nil {
12515                 if err == io.EOF {
12516                         chk(io.EOF)
12517                 }
12518                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
12519         }
12520 }
12521
12522 func (obj *ToCltCloudParams) Serialize(w io.Writer) {
12523         {
12524                 x := (*(*(struct {
12525                         Density      float32
12526                         DiffuseColor color.NRGBA
12527                         AmbientColor color.NRGBA
12528                         Height       float32
12529                         Thickness    float32
12530                         Speed        [2]float32
12531                 }))(obj)).Density
12532                 write32(w, math.Float32bits(x))
12533         }
12534         {
12535                 x := (*(*(struct {
12536                         Density      float32
12537                         DiffuseColor color.NRGBA
12538                         AmbientColor color.NRGBA
12539                         Height       float32
12540                         Thickness    float32
12541                         Speed        [2]float32
12542                 }))(obj)).DiffuseColor
12543                 w.Write([]byte{x.A, x.R, x.G, x.B})
12544         }
12545         {
12546                 x := (*(*(struct {
12547                         Density      float32
12548                         DiffuseColor color.NRGBA
12549                         AmbientColor color.NRGBA
12550                         Height       float32
12551                         Thickness    float32
12552                         Speed        [2]float32
12553                 }))(obj)).AmbientColor
12554                 w.Write([]byte{x.A, x.R, x.G, x.B})
12555         }
12556         {
12557                 x := (*(*(struct {
12558                         Density      float32
12559                         DiffuseColor color.NRGBA
12560                         AmbientColor color.NRGBA
12561                         Height       float32
12562                         Thickness    float32
12563                         Speed        [2]float32
12564                 }))(obj)).Height
12565                 write32(w, math.Float32bits(x))
12566         }
12567         {
12568                 x := (*(*(struct {
12569                         Density      float32
12570                         DiffuseColor color.NRGBA
12571                         AmbientColor color.NRGBA
12572                         Height       float32
12573                         Thickness    float32
12574                         Speed        [2]float32
12575                 }))(obj)).Thickness
12576                 write32(w, math.Float32bits(x))
12577         }
12578         for local206 := range (*(*(struct {
12579                 Density      float32
12580                 DiffuseColor color.NRGBA
12581                 AmbientColor color.NRGBA
12582                 Height       float32
12583                 Thickness    float32
12584                 Speed        [2]float32
12585         }))(obj)).Speed {
12586                 {
12587                         x := ((*(*(struct {
12588                                 Density      float32
12589                                 DiffuseColor color.NRGBA
12590                                 AmbientColor color.NRGBA
12591                                 Height       float32
12592                                 Thickness    float32
12593                                 Speed        [2]float32
12594                         }))(obj)).Speed)[local206]
12595                         write32(w, math.Float32bits(x))
12596                 }
12597         }
12598 }
12599
12600 func (obj *ToCltCloudParams) Deserialize(r io.Reader) {
12601         {
12602                 p := &(*(*(struct {
12603                         Density      float32
12604                         DiffuseColor color.NRGBA
12605                         AmbientColor color.NRGBA
12606                         Height       float32
12607                         Thickness    float32
12608                         Speed        [2]float32
12609                 }))(obj)).Density
12610                 *p = math.Float32frombits(read32(r))
12611         }
12612         {
12613                 p := &(*(*(struct {
12614                         Density      float32
12615                         DiffuseColor color.NRGBA
12616                         AmbientColor color.NRGBA
12617                         Height       float32
12618                         Thickness    float32
12619                         Speed        [2]float32
12620                 }))(obj)).DiffuseColor
12621                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12622         }
12623         {
12624                 p := &(*(*(struct {
12625                         Density      float32
12626                         DiffuseColor color.NRGBA
12627                         AmbientColor color.NRGBA
12628                         Height       float32
12629                         Thickness    float32
12630                         Speed        [2]float32
12631                 }))(obj)).AmbientColor
12632                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12633         }
12634         {
12635                 p := &(*(*(struct {
12636                         Density      float32
12637                         DiffuseColor color.NRGBA
12638                         AmbientColor color.NRGBA
12639                         Height       float32
12640                         Thickness    float32
12641                         Speed        [2]float32
12642                 }))(obj)).Height
12643                 *p = math.Float32frombits(read32(r))
12644         }
12645         {
12646                 p := &(*(*(struct {
12647                         Density      float32
12648                         DiffuseColor color.NRGBA
12649                         AmbientColor color.NRGBA
12650                         Height       float32
12651                         Thickness    float32
12652                         Speed        [2]float32
12653                 }))(obj)).Thickness
12654                 *p = math.Float32frombits(read32(r))
12655         }
12656         for local207 := range (*(*(struct {
12657                 Density      float32
12658                 DiffuseColor color.NRGBA
12659                 AmbientColor color.NRGBA
12660                 Height       float32
12661                 Thickness    float32
12662                 Speed        [2]float32
12663         }))(obj)).Speed {
12664                 {
12665                         p := &((*(*(struct {
12666                                 Density      float32
12667                                 DiffuseColor color.NRGBA
12668                                 AmbientColor color.NRGBA
12669                                 Height       float32
12670                                 Thickness    float32
12671                                 Speed        [2]float32
12672                         }))(obj)).Speed)[local207]
12673                         *p = math.Float32frombits(read32(r))
12674                 }
12675         }
12676 }
12677
12678 func (obj *ToCltFadeSound) Serialize(w io.Writer) {
12679         if err := pcall(func() {
12680                 ((*(*(struct {
12681                         ID   SoundID
12682                         Step float32
12683                         Gain float32
12684                 }))(obj)).ID).Serialize(w)
12685         }); err != nil {
12686                 if err == io.EOF {
12687                         chk(io.EOF)
12688                 }
12689                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
12690         }
12691         {
12692                 x := (*(*(struct {
12693                         ID   SoundID
12694                         Step float32
12695                         Gain float32
12696                 }))(obj)).Step
12697                 write32(w, math.Float32bits(x))
12698         }
12699         {
12700                 x := (*(*(struct {
12701                         ID   SoundID
12702                         Step float32
12703                         Gain float32
12704                 }))(obj)).Gain
12705                 write32(w, math.Float32bits(x))
12706         }
12707 }
12708
12709 func (obj *ToCltFadeSound) Deserialize(r io.Reader) {
12710         if err := pcall(func() {
12711                 ((*(*(struct {
12712                         ID   SoundID
12713                         Step float32
12714                         Gain float32
12715                 }))(obj)).ID).Deserialize(r)
12716         }); err != nil {
12717                 if err == io.EOF {
12718                         chk(io.EOF)
12719                 }
12720                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
12721         }
12722         {
12723                 p := &(*(*(struct {
12724                         ID   SoundID
12725                         Step float32
12726                         Gain float32
12727                 }))(obj)).Step
12728                 *p = math.Float32frombits(read32(r))
12729         }
12730         {
12731                 p := &(*(*(struct {
12732                         ID   SoundID
12733                         Step float32
12734                         Gain float32
12735                 }))(obj)).Gain
12736                 *p = math.Float32frombits(read32(r))
12737         }
12738 }
12739
12740 func (obj *ToCltUpdatePlayerList) Serialize(w io.Writer) {
12741         if err := pcall(func() {
12742                 ((*(*(struct {
12743                         Type    PlayerListUpdateType
12744                         Players []string
12745                 }))(obj)).Type).Serialize(w)
12746         }); err != nil {
12747                 if err == io.EOF {
12748                         chk(io.EOF)
12749                 }
12750                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerListUpdateType", err))
12751         }
12752         if len(((*(*(struct {
12753                 Type    PlayerListUpdateType
12754                 Players []string
12755         }))(obj)).Players)) > math.MaxUint16 {
12756                 chk(ErrTooLong)
12757         }
12758         {
12759                 x := uint16(len(((*(*(struct {
12760                         Type    PlayerListUpdateType
12761                         Players []string
12762                 }))(obj)).Players)))
12763                 write16(w, uint16(x))
12764         }
12765         for local208 := range (*(*(struct {
12766                 Type    PlayerListUpdateType
12767                 Players []string
12768         }))(obj)).Players {
12769                 if len(([]byte(((*(*(struct {
12770                         Type    PlayerListUpdateType
12771                         Players []string
12772                 }))(obj)).Players)[local208]))) > math.MaxUint16 {
12773                         chk(ErrTooLong)
12774                 }
12775                 {
12776                         x := uint16(len(([]byte(((*(*(struct {
12777                                 Type    PlayerListUpdateType
12778                                 Players []string
12779                         }))(obj)).Players)[local208]))))
12780                         write16(w, uint16(x))
12781                 }
12782                 {
12783                         _, err := w.Write(([]byte(((*(*(struct {
12784                                 Type    PlayerListUpdateType
12785                                 Players []string
12786                         }))(obj)).Players)[local208]))[:])
12787                         chk(err)
12788                 }
12789         }
12790 }
12791
12792 func (obj *ToCltUpdatePlayerList) Deserialize(r io.Reader) {
12793         if err := pcall(func() {
12794                 ((*(*(struct {
12795                         Type    PlayerListUpdateType
12796                         Players []string
12797                 }))(obj)).Type).Deserialize(r)
12798         }); err != nil {
12799                 if err == io.EOF {
12800                         chk(io.EOF)
12801                 }
12802                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerListUpdateType", err))
12803         }
12804         var local209 uint16
12805         {
12806                 p := &local209
12807                 *p = read16(r)
12808         }
12809         ((*(*(struct {
12810                 Type    PlayerListUpdateType
12811                 Players []string
12812         }))(obj)).Players) = make([]string, local209)
12813         for local210 := range (*(*(struct {
12814                 Type    PlayerListUpdateType
12815                 Players []string
12816         }))(obj)).Players {
12817                 var local211 []uint8
12818                 var local212 uint16
12819                 {
12820                         p := &local212
12821                         *p = read16(r)
12822                 }
12823                 (local211) = make([]uint8, local212)
12824                 {
12825                         _, err := io.ReadFull(r, (local211)[:])
12826                         chk(err)
12827                 }
12828                 (((*(*(struct {
12829                         Type    PlayerListUpdateType
12830                         Players []string
12831                 }))(obj)).Players)[local210]) = string(local211)
12832         }
12833 }
12834
12835 func (obj *ToCltModChanMsg) Serialize(w io.Writer) {
12836         if len(([]byte((*(*(struct {
12837                 Channel string
12838                 Sender  string
12839                 Msg     string
12840         }))(obj)).Channel))) > math.MaxUint16 {
12841                 chk(ErrTooLong)
12842         }
12843         {
12844                 x := uint16(len(([]byte((*(*(struct {
12845                         Channel string
12846                         Sender  string
12847                         Msg     string
12848                 }))(obj)).Channel))))
12849                 write16(w, uint16(x))
12850         }
12851         {
12852                 _, err := w.Write(([]byte((*(*(struct {
12853                         Channel string
12854                         Sender  string
12855                         Msg     string
12856                 }))(obj)).Channel))[:])
12857                 chk(err)
12858         }
12859         if len(([]byte((*(*(struct {
12860                 Channel string
12861                 Sender  string
12862                 Msg     string
12863         }))(obj)).Sender))) > math.MaxUint16 {
12864                 chk(ErrTooLong)
12865         }
12866         {
12867                 x := uint16(len(([]byte((*(*(struct {
12868                         Channel string
12869                         Sender  string
12870                         Msg     string
12871                 }))(obj)).Sender))))
12872                 write16(w, uint16(x))
12873         }
12874         {
12875                 _, err := w.Write(([]byte((*(*(struct {
12876                         Channel string
12877                         Sender  string
12878                         Msg     string
12879                 }))(obj)).Sender))[:])
12880                 chk(err)
12881         }
12882         if len(([]byte((*(*(struct {
12883                 Channel string
12884                 Sender  string
12885                 Msg     string
12886         }))(obj)).Msg))) > math.MaxUint16 {
12887                 chk(ErrTooLong)
12888         }
12889         {
12890                 x := uint16(len(([]byte((*(*(struct {
12891                         Channel string
12892                         Sender  string
12893                         Msg     string
12894                 }))(obj)).Msg))))
12895                 write16(w, uint16(x))
12896         }
12897         {
12898                 _, err := w.Write(([]byte((*(*(struct {
12899                         Channel string
12900                         Sender  string
12901                         Msg     string
12902                 }))(obj)).Msg))[:])
12903                 chk(err)
12904         }
12905 }
12906
12907 func (obj *ToCltModChanMsg) Deserialize(r io.Reader) {
12908         var local213 []uint8
12909         var local214 uint16
12910         {
12911                 p := &local214
12912                 *p = read16(r)
12913         }
12914         (local213) = make([]uint8, local214)
12915         {
12916                 _, err := io.ReadFull(r, (local213)[:])
12917                 chk(err)
12918         }
12919         ((*(*(struct {
12920                 Channel string
12921                 Sender  string
12922                 Msg     string
12923         }))(obj)).Channel) = string(local213)
12924         var local215 []uint8
12925         var local216 uint16
12926         {
12927                 p := &local216
12928                 *p = read16(r)
12929         }
12930         (local215) = make([]uint8, local216)
12931         {
12932                 _, err := io.ReadFull(r, (local215)[:])
12933                 chk(err)
12934         }
12935         ((*(*(struct {
12936                 Channel string
12937                 Sender  string
12938                 Msg     string
12939         }))(obj)).Sender) = string(local215)
12940         var local217 []uint8
12941         var local218 uint16
12942         {
12943                 p := &local218
12944                 *p = read16(r)
12945         }
12946         (local217) = make([]uint8, local218)
12947         {
12948                 _, err := io.ReadFull(r, (local217)[:])
12949                 chk(err)
12950         }
12951         ((*(*(struct {
12952                 Channel string
12953                 Sender  string
12954                 Msg     string
12955         }))(obj)).Msg) = string(local217)
12956 }
12957
12958 func (obj *ToCltModChanSig) Serialize(w io.Writer) {
12959         if err := pcall(func() {
12960                 ((*(*(struct {
12961                         Signal  ModChanSig
12962                         Channel string
12963                 }))(obj)).Signal).Serialize(w)
12964         }); err != nil {
12965                 if err == io.EOF {
12966                         chk(io.EOF)
12967                 }
12968                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ModChanSig", err))
12969         }
12970         if len(([]byte((*(*(struct {
12971                 Signal  ModChanSig
12972                 Channel string
12973         }))(obj)).Channel))) > math.MaxUint16 {
12974                 chk(ErrTooLong)
12975         }
12976         {
12977                 x := uint16(len(([]byte((*(*(struct {
12978                         Signal  ModChanSig
12979                         Channel string
12980                 }))(obj)).Channel))))
12981                 write16(w, uint16(x))
12982         }
12983         {
12984                 _, err := w.Write(([]byte((*(*(struct {
12985                         Signal  ModChanSig
12986                         Channel string
12987                 }))(obj)).Channel))[:])
12988                 chk(err)
12989         }
12990 }
12991
12992 func (obj *ToCltModChanSig) Deserialize(r io.Reader) {
12993         if err := pcall(func() {
12994                 ((*(*(struct {
12995                         Signal  ModChanSig
12996                         Channel string
12997                 }))(obj)).Signal).Deserialize(r)
12998         }); err != nil {
12999                 if err == io.EOF {
13000                         chk(io.EOF)
13001                 }
13002                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ModChanSig", err))
13003         }
13004         var local219 []uint8
13005         var local220 uint16
13006         {
13007                 p := &local220
13008                 *p = read16(r)
13009         }
13010         (local219) = make([]uint8, local220)
13011         {
13012                 _, err := io.ReadFull(r, (local219)[:])
13013                 chk(err)
13014         }
13015         ((*(*(struct {
13016                 Signal  ModChanSig
13017                 Channel string
13018         }))(obj)).Channel) = string(local219)
13019 }
13020
13021 func (obj *ToCltNodeMetasChanged) Serialize(w io.Writer) {
13022         {
13023                 ow := w
13024                 w := new(bytes.Buffer)
13025                 {
13026                         x := (*(*(struct {
13027                                 //mt:lenhdr 32
13028                                 Changed map[[3]int16]*NodeMeta
13029                         }))(obj)).Changed
13030                         {
13031                                 w := zlib.NewWriter(w)
13032                                 if x == nil {
13033                                         write8(w, 0)
13034                                 } else {
13035                                         write8(w, 2)
13036                                         if len(x) > math.MaxUint16 {
13037                                                 chk(ErrTooLong)
13038                                         }
13039                                         write16(w, uint16(len(x)))
13040                                         keys := make([][3]int16, 0, len(x))
13041                                         for key := range x {
13042                                                 keys = append(keys, key)
13043                                         }
13044                                         sort.Slice(keys, func(i, j int) bool {
13045                                                 p, q := keys[i], keys[j]
13046                                                 for i := range p {
13047                                                         switch {
13048                                                         case p[i] < q[i]:
13049                                                                 return true
13050                                                         case p[i] > q[i]:
13051                                                                 return false
13052                                                         }
13053                                                 }
13054                                                 return false
13055                                         })
13056                                         for _, key := range keys {
13057                                                 for _, n := range key {
13058                                                         write16(w, uint16(n))
13059                                                 }
13060                                                 chk(serialize(w, x[key]))
13061                                         }
13062                                 }
13063                                 chk(w.Close())
13064                         }
13065                 }
13066                 {
13067                         buf := w
13068                         w := ow
13069                         if len((buf.Bytes())) > math.MaxUint32 {
13070                                 chk(ErrTooLong)
13071                         }
13072                         {
13073                                 x := uint32(len((buf.Bytes())))
13074                                 write32(w, uint32(x))
13075                         }
13076                         {
13077                                 _, err := w.Write((buf.Bytes())[:])
13078                                 chk(err)
13079                         }
13080                 }
13081         }
13082 }
13083
13084 func (obj *ToCltNodeMetasChanged) Deserialize(r io.Reader) {
13085         {
13086                 var n uint32
13087                 {
13088                         p := &n
13089                         *p = read32(r)
13090                 }
13091                 r := &io.LimitedReader{R: r, N: int64(n)}
13092                 {
13093                         p := &(*(*(struct {
13094                                 //mt:lenhdr 32
13095                                 Changed map[[3]int16]*NodeMeta
13096                         }))(obj)).Changed
13097                         {
13098                                 r, err := zlib.NewReader(byteReader{r})
13099                                 chk(err)
13100                                 switch ver := read8(r); ver {
13101                                 case 0:
13102                                         *p = nil
13103                                 case 2:
13104                                         n := read16(r)
13105                                         *p = make(map[[3]int16]*NodeMeta, n)
13106                                         for ; n > 0; n-- {
13107                                                 var pos [3]int16
13108                                                 for i := range pos {
13109                                                         pos[i] = int16(read16(r))
13110                                                 }
13111                                                 nm := new(NodeMeta)
13112                                                 chk(deserialize(r, nm))
13113                                                 (*p)[pos] = nm
13114                                         }
13115                                 default:
13116                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
13117                                 }
13118                                 chk(r.Close())
13119                         }
13120                 }
13121                 if r.N > 0 {
13122                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
13123                 }
13124         }
13125 }
13126
13127 func (obj *ToCltSunParams) Serialize(w io.Writer) {
13128         {
13129                 x := (*(*(struct {
13130                         Visible bool
13131                         Texture
13132                         ToneMap Texture
13133                         Rise    Texture
13134                         Rising  bool
13135                         Size    float32
13136                 }))(obj)).Visible
13137                 if x {
13138                         write8(w, 1)
13139                 } else {
13140                         write8(w, 0)
13141                 }
13142         }
13143         if err := pcall(func() {
13144                 ((*(*(struct {
13145                         Visible bool
13146                         Texture
13147                         ToneMap Texture
13148                         Rise    Texture
13149                         Rising  bool
13150                         Size    float32
13151                 }))(obj)).Texture).Serialize(w)
13152         }); err != nil {
13153                 if err == io.EOF {
13154                         chk(io.EOF)
13155                 }
13156                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13157         }
13158         if err := pcall(func() {
13159                 ((*(*(struct {
13160                         Visible bool
13161                         Texture
13162                         ToneMap Texture
13163                         Rise    Texture
13164                         Rising  bool
13165                         Size    float32
13166                 }))(obj)).ToneMap).Serialize(w)
13167         }); err != nil {
13168                 if err == io.EOF {
13169                         chk(io.EOF)
13170                 }
13171                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13172         }
13173         if err := pcall(func() {
13174                 ((*(*(struct {
13175                         Visible bool
13176                         Texture
13177                         ToneMap Texture
13178                         Rise    Texture
13179                         Rising  bool
13180                         Size    float32
13181                 }))(obj)).Rise).Serialize(w)
13182         }); err != nil {
13183                 if err == io.EOF {
13184                         chk(io.EOF)
13185                 }
13186                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13187         }
13188         {
13189                 x := (*(*(struct {
13190                         Visible bool
13191                         Texture
13192                         ToneMap Texture
13193                         Rise    Texture
13194                         Rising  bool
13195                         Size    float32
13196                 }))(obj)).Rising
13197                 if x {
13198                         write8(w, 1)
13199                 } else {
13200                         write8(w, 0)
13201                 }
13202         }
13203         {
13204                 x := (*(*(struct {
13205                         Visible bool
13206                         Texture
13207                         ToneMap Texture
13208                         Rise    Texture
13209                         Rising  bool
13210                         Size    float32
13211                 }))(obj)).Size
13212                 write32(w, math.Float32bits(x))
13213         }
13214 }
13215
13216 func (obj *ToCltSunParams) Deserialize(r io.Reader) {
13217         {
13218                 p := &(*(*(struct {
13219                         Visible bool
13220                         Texture
13221                         ToneMap Texture
13222                         Rise    Texture
13223                         Rising  bool
13224                         Size    float32
13225                 }))(obj)).Visible
13226                 switch n := read8(r); n {
13227                 case 0:
13228                         *p = false
13229                 case 1:
13230                         *p = true
13231                 default:
13232                         chk(fmt.Errorf("invalid bool: %d", n))
13233                 }
13234         }
13235         if err := pcall(func() {
13236                 ((*(*(struct {
13237                         Visible bool
13238                         Texture
13239                         ToneMap Texture
13240                         Rise    Texture
13241                         Rising  bool
13242                         Size    float32
13243                 }))(obj)).Texture).Deserialize(r)
13244         }); err != nil {
13245                 if err == io.EOF {
13246                         chk(io.EOF)
13247                 }
13248                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13249         }
13250         if err := pcall(func() {
13251                 ((*(*(struct {
13252                         Visible bool
13253                         Texture
13254                         ToneMap Texture
13255                         Rise    Texture
13256                         Rising  bool
13257                         Size    float32
13258                 }))(obj)).ToneMap).Deserialize(r)
13259         }); err != nil {
13260                 if err == io.EOF {
13261                         chk(io.EOF)
13262                 }
13263                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13264         }
13265         if err := pcall(func() {
13266                 ((*(*(struct {
13267                         Visible bool
13268                         Texture
13269                         ToneMap Texture
13270                         Rise    Texture
13271                         Rising  bool
13272                         Size    float32
13273                 }))(obj)).Rise).Deserialize(r)
13274         }); err != nil {
13275                 if err == io.EOF {
13276                         chk(io.EOF)
13277                 }
13278                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13279         }
13280         {
13281                 p := &(*(*(struct {
13282                         Visible bool
13283                         Texture
13284                         ToneMap Texture
13285                         Rise    Texture
13286                         Rising  bool
13287                         Size    float32
13288                 }))(obj)).Rising
13289                 switch n := read8(r); n {
13290                 case 0:
13291                         *p = false
13292                 case 1:
13293                         *p = true
13294                 default:
13295                         chk(fmt.Errorf("invalid bool: %d", n))
13296                 }
13297         }
13298         {
13299                 p := &(*(*(struct {
13300                         Visible bool
13301                         Texture
13302                         ToneMap Texture
13303                         Rise    Texture
13304                         Rising  bool
13305                         Size    float32
13306                 }))(obj)).Size
13307                 *p = math.Float32frombits(read32(r))
13308         }
13309 }
13310
13311 func (obj *ToCltMoonParams) Serialize(w io.Writer) {
13312         {
13313                 x := (*(*(struct {
13314                         Visible bool
13315                         Texture
13316                         ToneMap Texture
13317                         Size    float32
13318                 }))(obj)).Visible
13319                 if x {
13320                         write8(w, 1)
13321                 } else {
13322                         write8(w, 0)
13323                 }
13324         }
13325         if err := pcall(func() {
13326                 ((*(*(struct {
13327                         Visible bool
13328                         Texture
13329                         ToneMap Texture
13330                         Size    float32
13331                 }))(obj)).Texture).Serialize(w)
13332         }); err != nil {
13333                 if err == io.EOF {
13334                         chk(io.EOF)
13335                 }
13336                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13337         }
13338         if err := pcall(func() {
13339                 ((*(*(struct {
13340                         Visible bool
13341                         Texture
13342                         ToneMap Texture
13343                         Size    float32
13344                 }))(obj)).ToneMap).Serialize(w)
13345         }); err != nil {
13346                 if err == io.EOF {
13347                         chk(io.EOF)
13348                 }
13349                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13350         }
13351         {
13352                 x := (*(*(struct {
13353                         Visible bool
13354                         Texture
13355                         ToneMap Texture
13356                         Size    float32
13357                 }))(obj)).Size
13358                 write32(w, math.Float32bits(x))
13359         }
13360 }
13361
13362 func (obj *ToCltMoonParams) Deserialize(r io.Reader) {
13363         {
13364                 p := &(*(*(struct {
13365                         Visible bool
13366                         Texture
13367                         ToneMap Texture
13368                         Size    float32
13369                 }))(obj)).Visible
13370                 switch n := read8(r); n {
13371                 case 0:
13372                         *p = false
13373                 case 1:
13374                         *p = true
13375                 default:
13376                         chk(fmt.Errorf("invalid bool: %d", n))
13377                 }
13378         }
13379         if err := pcall(func() {
13380                 ((*(*(struct {
13381                         Visible bool
13382                         Texture
13383                         ToneMap Texture
13384                         Size    float32
13385                 }))(obj)).Texture).Deserialize(r)
13386         }); err != nil {
13387                 if err == io.EOF {
13388                         chk(io.EOF)
13389                 }
13390                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13391         }
13392         if err := pcall(func() {
13393                 ((*(*(struct {
13394                         Visible bool
13395                         Texture
13396                         ToneMap Texture
13397                         Size    float32
13398                 }))(obj)).ToneMap).Deserialize(r)
13399         }); err != nil {
13400                 if err == io.EOF {
13401                         chk(io.EOF)
13402                 }
13403                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13404         }
13405         {
13406                 p := &(*(*(struct {
13407                         Visible bool
13408                         Texture
13409                         ToneMap Texture
13410                         Size    float32
13411                 }))(obj)).Size
13412                 *p = math.Float32frombits(read32(r))
13413         }
13414 }
13415
13416 func (obj *ToCltStarParams) Serialize(w io.Writer) {
13417         {
13418                 x := (*(*(struct {
13419                         Visible bool
13420                         Count   uint32
13421                         Color   color.NRGBA
13422                         Size    float32
13423                 }))(obj)).Visible
13424                 if x {
13425                         write8(w, 1)
13426                 } else {
13427                         write8(w, 0)
13428                 }
13429         }
13430         {
13431                 x := (*(*(struct {
13432                         Visible bool
13433                         Count   uint32
13434                         Color   color.NRGBA
13435                         Size    float32
13436                 }))(obj)).Count
13437                 write32(w, uint32(x))
13438         }
13439         {
13440                 x := (*(*(struct {
13441                         Visible bool
13442                         Count   uint32
13443                         Color   color.NRGBA
13444                         Size    float32
13445                 }))(obj)).Color
13446                 w.Write([]byte{x.A, x.R, x.G, x.B})
13447         }
13448         {
13449                 x := (*(*(struct {
13450                         Visible bool
13451                         Count   uint32
13452                         Color   color.NRGBA
13453                         Size    float32
13454                 }))(obj)).Size
13455                 write32(w, math.Float32bits(x))
13456         }
13457 }
13458
13459 func (obj *ToCltStarParams) Deserialize(r io.Reader) {
13460         {
13461                 p := &(*(*(struct {
13462                         Visible bool
13463                         Count   uint32
13464                         Color   color.NRGBA
13465                         Size    float32
13466                 }))(obj)).Visible
13467                 switch n := read8(r); n {
13468                 case 0:
13469                         *p = false
13470                 case 1:
13471                         *p = true
13472                 default:
13473                         chk(fmt.Errorf("invalid bool: %d", n))
13474                 }
13475         }
13476         {
13477                 p := &(*(*(struct {
13478                         Visible bool
13479                         Count   uint32
13480                         Color   color.NRGBA
13481                         Size    float32
13482                 }))(obj)).Count
13483                 *p = read32(r)
13484         }
13485         {
13486                 p := &(*(*(struct {
13487                         Visible bool
13488                         Count   uint32
13489                         Color   color.NRGBA
13490                         Size    float32
13491                 }))(obj)).Color
13492                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13493         }
13494         {
13495                 p := &(*(*(struct {
13496                         Visible bool
13497                         Count   uint32
13498                         Color   color.NRGBA
13499                         Size    float32
13500                 }))(obj)).Size
13501                 *p = math.Float32frombits(read32(r))
13502         }
13503 }
13504
13505 func (obj *ToCltSRPBytesSaltB) Serialize(w io.Writer) {
13506         if len(((*(*(struct {
13507                 Salt, B []byte
13508         }))(obj)).Salt)) > math.MaxUint16 {
13509                 chk(ErrTooLong)
13510         }
13511         {
13512                 x := uint16(len(((*(*(struct {
13513                         Salt, B []byte
13514                 }))(obj)).Salt)))
13515                 write16(w, uint16(x))
13516         }
13517         {
13518                 _, err := w.Write(((*(*(struct {
13519                         Salt, B []byte
13520                 }))(obj)).Salt)[:])
13521                 chk(err)
13522         }
13523         if len(((*(*(struct {
13524                 Salt, B []byte
13525         }))(obj)).B)) > math.MaxUint16 {
13526                 chk(ErrTooLong)
13527         }
13528         {
13529                 x := uint16(len(((*(*(struct {
13530                         Salt, B []byte
13531                 }))(obj)).B)))
13532                 write16(w, uint16(x))
13533         }
13534         {
13535                 _, err := w.Write(((*(*(struct {
13536                         Salt, B []byte
13537                 }))(obj)).B)[:])
13538                 chk(err)
13539         }
13540 }
13541
13542 func (obj *ToCltSRPBytesSaltB) Deserialize(r io.Reader) {
13543         var local221 uint16
13544         {
13545                 p := &local221
13546                 *p = read16(r)
13547         }
13548         ((*(*(struct {
13549                 Salt, B []byte
13550         }))(obj)).Salt) = make([]byte, local221)
13551         {
13552                 _, err := io.ReadFull(r, ((*(*(struct {
13553                         Salt, B []byte
13554                 }))(obj)).Salt)[:])
13555                 chk(err)
13556         }
13557         var local222 uint16
13558         {
13559                 p := &local222
13560                 *p = read16(r)
13561         }
13562         ((*(*(struct {
13563                 Salt, B []byte
13564         }))(obj)).B) = make([]byte, local222)
13565         {
13566                 _, err := io.ReadFull(r, ((*(*(struct {
13567                         Salt, B []byte
13568                 }))(obj)).B)[:])
13569                 chk(err)
13570         }
13571 }
13572
13573 func (obj *ToCltFormspecPrepend) Serialize(w io.Writer) {
13574         if len(([]byte((*(*(struct {
13575                 Prepend string
13576         }))(obj)).Prepend))) > math.MaxUint16 {
13577                 chk(ErrTooLong)
13578         }
13579         {
13580                 x := uint16(len(([]byte((*(*(struct {
13581                         Prepend string
13582                 }))(obj)).Prepend))))
13583                 write16(w, uint16(x))
13584         }
13585         {
13586                 _, err := w.Write(([]byte((*(*(struct {
13587                         Prepend string
13588                 }))(obj)).Prepend))[:])
13589                 chk(err)
13590         }
13591 }
13592
13593 func (obj *ToCltFormspecPrepend) Deserialize(r io.Reader) {
13594         var local223 []uint8
13595         var local224 uint16
13596         {
13597                 p := &local224
13598                 *p = read16(r)
13599         }
13600         (local223) = make([]uint8, local224)
13601         {
13602                 _, err := io.ReadFull(r, (local223)[:])
13603                 chk(err)
13604         }
13605         ((*(*(struct {
13606                 Prepend string
13607         }))(obj)).Prepend) = string(local223)
13608 }
13609
13610 func (obj *AOCmdProps) Serialize(w io.Writer) {
13611         if err := pcall(func() {
13612                 ((*(*(struct {
13613                         Props AOProps
13614                 }))(obj)).Props).Serialize(w)
13615         }); err != nil {
13616                 if err == io.EOF {
13617                         chk(io.EOF)
13618                 }
13619                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOProps", err))
13620         }
13621 }
13622
13623 func (obj *AOCmdProps) Deserialize(r io.Reader) {
13624         if err := pcall(func() {
13625                 ((*(*(struct {
13626                         Props AOProps
13627                 }))(obj)).Props).Deserialize(r)
13628         }); err != nil {
13629                 if err == io.EOF {
13630                         chk(io.EOF)
13631                 }
13632                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOProps", err))
13633         }
13634 }
13635
13636 func (obj *AOCmdPos) Serialize(w io.Writer) {
13637         if err := pcall(func() {
13638                 ((*(*(struct {
13639                         Pos AOPos
13640                 }))(obj)).Pos).Serialize(w)
13641         }); err != nil {
13642                 if err == io.EOF {
13643                         chk(io.EOF)
13644                 }
13645                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPos", err))
13646         }
13647 }
13648
13649 func (obj *AOCmdPos) Deserialize(r io.Reader) {
13650         if err := pcall(func() {
13651                 ((*(*(struct {
13652                         Pos AOPos
13653                 }))(obj)).Pos).Deserialize(r)
13654         }); err != nil {
13655                 if err == io.EOF {
13656                         chk(io.EOF)
13657                 }
13658                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPos", err))
13659         }
13660 }
13661
13662 func (obj *AOCmdTextureMod) Serialize(w io.Writer) {
13663         if err := pcall(func() {
13664                 ((*(*(struct {
13665                         Mod Texture // suffix
13666                 }))(obj)).Mod).Serialize(w)
13667         }); err != nil {
13668                 if err == io.EOF {
13669                         chk(io.EOF)
13670                 }
13671                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13672         }
13673 }
13674
13675 func (obj *AOCmdTextureMod) Deserialize(r io.Reader) {
13676         if err := pcall(func() {
13677                 ((*(*(struct {
13678                         Mod Texture // suffix
13679                 }))(obj)).Mod).Deserialize(r)
13680         }); err != nil {
13681                 if err == io.EOF {
13682                         chk(io.EOF)
13683                 }
13684                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13685         }
13686 }
13687
13688 func (obj *AOCmdSprite) Serialize(w io.Writer) {
13689         if err := pcall(func() {
13690                 ((*(*(struct {
13691                         Sprite AOSprite
13692                 }))(obj)).Sprite).Serialize(w)
13693         }); err != nil {
13694                 if err == io.EOF {
13695                         chk(io.EOF)
13696                 }
13697                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOSprite", err))
13698         }
13699 }
13700
13701 func (obj *AOCmdSprite) Deserialize(r io.Reader) {
13702         if err := pcall(func() {
13703                 ((*(*(struct {
13704                         Sprite AOSprite
13705                 }))(obj)).Sprite).Deserialize(r)
13706         }); err != nil {
13707                 if err == io.EOF {
13708                         chk(io.EOF)
13709                 }
13710                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOSprite", err))
13711         }
13712 }
13713
13714 func (obj *AOCmdHP) Serialize(w io.Writer) {
13715         {
13716                 x := (*(*(struct {
13717                         HP uint16
13718                 }))(obj)).HP
13719                 write16(w, uint16(x))
13720         }
13721 }
13722
13723 func (obj *AOCmdHP) Deserialize(r io.Reader) {
13724         {
13725                 p := &(*(*(struct {
13726                         HP uint16
13727                 }))(obj)).HP
13728                 *p = read16(r)
13729         }
13730 }
13731
13732 func (obj *AOCmdArmorGroups) Serialize(w io.Writer) {
13733         if len(((*(*(struct {
13734                 Armor []Group
13735         }))(obj)).Armor)) > math.MaxUint16 {
13736                 chk(ErrTooLong)
13737         }
13738         {
13739                 x := uint16(len(((*(*(struct {
13740                         Armor []Group
13741                 }))(obj)).Armor)))
13742                 write16(w, uint16(x))
13743         }
13744         for local225 := range (*(*(struct {
13745                 Armor []Group
13746         }))(obj)).Armor {
13747                 if err := pcall(func() {
13748                         (((*(*(struct {
13749                                 Armor []Group
13750                         }))(obj)).Armor)[local225]).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.Group", err))
13756                 }
13757         }
13758 }
13759
13760 func (obj *AOCmdArmorGroups) Deserialize(r io.Reader) {
13761         var local226 uint16
13762         {
13763                 p := &local226
13764                 *p = read16(r)
13765         }
13766         ((*(*(struct {
13767                 Armor []Group
13768         }))(obj)).Armor) = make([]Group, local226)
13769         for local227 := range (*(*(struct {
13770                 Armor []Group
13771         }))(obj)).Armor {
13772                 if err := pcall(func() {
13773                         (((*(*(struct {
13774                                 Armor []Group
13775                         }))(obj)).Armor)[local227]).Deserialize(r)
13776                 }); err != nil {
13777                         if err == io.EOF {
13778                                 chk(io.EOF)
13779                         }
13780                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
13781                 }
13782         }
13783 }
13784
13785 func (obj *AOCmdAnim) Serialize(w io.Writer) {
13786         if err := pcall(func() {
13787                 ((*(*(struct {
13788                         Anim AOAnim
13789                 }))(obj)).Anim).Serialize(w)
13790         }); err != nil {
13791                 if err == io.EOF {
13792                         chk(io.EOF)
13793                 }
13794                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAnim", err))
13795         }
13796 }
13797
13798 func (obj *AOCmdAnim) Deserialize(r io.Reader) {
13799         if err := pcall(func() {
13800                 ((*(*(struct {
13801                         Anim AOAnim
13802                 }))(obj)).Anim).Deserialize(r)
13803         }); err != nil {
13804                 if err == io.EOF {
13805                         chk(io.EOF)
13806                 }
13807                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAnim", err))
13808         }
13809 }
13810
13811 func (obj *AOCmdBonePos) Serialize(w io.Writer) {
13812         if len(([]byte((*(*(struct {
13813                 Bone string
13814                 Pos  AOBonePos
13815         }))(obj)).Bone))) > math.MaxUint16 {
13816                 chk(ErrTooLong)
13817         }
13818         {
13819                 x := uint16(len(([]byte((*(*(struct {
13820                         Bone string
13821                         Pos  AOBonePos
13822                 }))(obj)).Bone))))
13823                 write16(w, uint16(x))
13824         }
13825         {
13826                 _, err := w.Write(([]byte((*(*(struct {
13827                         Bone string
13828                         Pos  AOBonePos
13829                 }))(obj)).Bone))[:])
13830                 chk(err)
13831         }
13832         if err := pcall(func() {
13833                 ((*(*(struct {
13834                         Bone string
13835                         Pos  AOBonePos
13836                 }))(obj)).Pos).Serialize(w)
13837         }); err != nil {
13838                 if err == io.EOF {
13839                         chk(io.EOF)
13840                 }
13841                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOBonePos", err))
13842         }
13843 }
13844
13845 func (obj *AOCmdBonePos) Deserialize(r io.Reader) {
13846         var local228 []uint8
13847         var local229 uint16
13848         {
13849                 p := &local229
13850                 *p = read16(r)
13851         }
13852         (local228) = make([]uint8, local229)
13853         {
13854                 _, err := io.ReadFull(r, (local228)[:])
13855                 chk(err)
13856         }
13857         ((*(*(struct {
13858                 Bone string
13859                 Pos  AOBonePos
13860         }))(obj)).Bone) = string(local228)
13861         if err := pcall(func() {
13862                 ((*(*(struct {
13863                         Bone string
13864                         Pos  AOBonePos
13865                 }))(obj)).Pos).Deserialize(r)
13866         }); err != nil {
13867                 if err == io.EOF {
13868                         chk(io.EOF)
13869                 }
13870                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOBonePos", err))
13871         }
13872 }
13873
13874 func (obj *AOCmdAttach) Serialize(w io.Writer) {
13875         if err := pcall(func() {
13876                 ((*(*(struct {
13877                         Attach AOAttach
13878                 }))(obj)).Attach).Serialize(w)
13879         }); err != nil {
13880                 if err == io.EOF {
13881                         chk(io.EOF)
13882                 }
13883                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAttach", err))
13884         }
13885 }
13886
13887 func (obj *AOCmdAttach) Deserialize(r io.Reader) {
13888         if err := pcall(func() {
13889                 ((*(*(struct {
13890                         Attach AOAttach
13891                 }))(obj)).Attach).Deserialize(r)
13892         }); err != nil {
13893                 if err == io.EOF {
13894                         chk(io.EOF)
13895                 }
13896                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAttach", err))
13897         }
13898 }
13899
13900 func (obj *AOCmdPhysOverride) Serialize(w io.Writer) {
13901         if err := pcall(func() {
13902                 ((*(*(struct {
13903                         Phys AOPhysOverride
13904                 }))(obj)).Phys).Serialize(w)
13905         }); err != nil {
13906                 if err == io.EOF {
13907                         chk(io.EOF)
13908                 }
13909                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPhysOverride", err))
13910         }
13911 }
13912
13913 func (obj *AOCmdPhysOverride) Deserialize(r io.Reader) {
13914         if err := pcall(func() {
13915                 ((*(*(struct {
13916                         Phys AOPhysOverride
13917                 }))(obj)).Phys).Deserialize(r)
13918         }); err != nil {
13919                 if err == io.EOF {
13920                         chk(io.EOF)
13921                 }
13922                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPhysOverride", err))
13923         }
13924 }
13925
13926 func (obj *AOCmdSpawnInfant) Serialize(w io.Writer) {
13927         if err := pcall(func() {
13928                 ((*(*(struct {
13929                         ID AOID
13930                 }))(obj)).ID).Serialize(w)
13931         }); err != nil {
13932                 if err == io.EOF {
13933                         chk(io.EOF)
13934                 }
13935                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
13936         }
13937         {
13938                 local230 := genericCAO
13939                 if err := pcall(func() {
13940                         (local230).Serialize(w)
13941                 }); err != nil {
13942                         if err == io.EOF {
13943                                 chk(io.EOF)
13944                         }
13945                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
13946                 }
13947         }
13948 }
13949
13950 func (obj *AOCmdSpawnInfant) Deserialize(r io.Reader) {
13951         if err := pcall(func() {
13952                 ((*(*(struct {
13953                         ID AOID
13954                 }))(obj)).ID).Deserialize(r)
13955         }); err != nil {
13956                 if err == io.EOF {
13957                         chk(io.EOF)
13958                 }
13959                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
13960         }
13961         {
13962                 var local231 aoType
13963                 local232 := genericCAO
13964                 if err := pcall(func() {
13965                         (local231).Deserialize(r)
13966                 }); err != nil {
13967                         if err == io.EOF {
13968                                 chk(io.EOF)
13969                         }
13970                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
13971                 }
13972                 if local231 != local232 {
13973                         chk(fmt.Errorf("const %v: %v", "genericCAO", local231))
13974                 }
13975         }
13976 }
13977
13978 func (obj *AOCmdAnimSpeed) Serialize(w io.Writer) {
13979         {
13980                 x := (*(*(struct {
13981                         Speed float32
13982                 }))(obj)).Speed
13983                 write32(w, math.Float32bits(x))
13984         }
13985 }
13986
13987 func (obj *AOCmdAnimSpeed) Deserialize(r io.Reader) {
13988         {
13989                 p := &(*(*(struct {
13990                         Speed float32
13991                 }))(obj)).Speed
13992                 *p = math.Float32frombits(read32(r))
13993         }
13994 }
13995
13996 func (obj *NodeMeta) Serialize(w io.Writer) {
13997         if len(((*(*(struct {
13998                 //mt:len32
13999                 Fields []NodeMetaField
14000
14001                 Inv Inv
14002         }))(obj)).Fields)) > math.MaxUint32 {
14003                 chk(ErrTooLong)
14004         }
14005         {
14006                 x := uint32(len(((*(*(struct {
14007                         //mt:len32
14008                         Fields []NodeMetaField
14009
14010                         Inv Inv
14011                 }))(obj)).Fields)))
14012                 write32(w, uint32(x))
14013         }
14014         for local233 := range (*(*(struct {
14015                 //mt:len32
14016                 Fields []NodeMetaField
14017
14018                 Inv Inv
14019         }))(obj)).Fields {
14020                 if err := pcall(func() {
14021                         (((*(*(struct {
14022                                 //mt:len32
14023                                 Fields []NodeMetaField
14024
14025                                 Inv Inv
14026                         }))(obj)).Fields)[local233]).Serialize(w)
14027                 }); err != nil {
14028                         if err == io.EOF {
14029                                 chk(io.EOF)
14030                         }
14031                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeMetaField", err))
14032                 }
14033         }
14034         chk(((*(*(struct {
14035                 //mt:len32
14036                 Fields []NodeMetaField
14037
14038                 Inv Inv
14039         }))(obj)).Inv).Serialize(w))
14040 }
14041
14042 func (obj *NodeMeta) Deserialize(r io.Reader) {
14043         var local234 uint32
14044         {
14045                 p := &local234
14046                 *p = read32(r)
14047         }
14048         ((*(*(struct {
14049                 //mt:len32
14050                 Fields []NodeMetaField
14051
14052                 Inv Inv
14053         }))(obj)).Fields) = make([]NodeMetaField, local234)
14054         for local235 := range (*(*(struct {
14055                 //mt:len32
14056                 Fields []NodeMetaField
14057
14058                 Inv Inv
14059         }))(obj)).Fields {
14060                 if err := pcall(func() {
14061                         (((*(*(struct {
14062                                 //mt:len32
14063                                 Fields []NodeMetaField
14064
14065                                 Inv Inv
14066                         }))(obj)).Fields)[local235]).Deserialize(r)
14067                 }); err != nil {
14068                         if err == io.EOF {
14069                                 chk(io.EOF)
14070                         }
14071                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeMetaField", err))
14072                 }
14073         }
14074         chk(((*(*(struct {
14075                 //mt:len32
14076                 Fields []NodeMetaField
14077
14078                 Inv Inv
14079         }))(obj)).Inv).Deserialize(r))
14080 }
14081
14082 func (obj *MinimapMode) Serialize(w io.Writer) {
14083         if err := pcall(func() {
14084                 ((*(*(struct {
14085                         Type  MinimapType
14086                         Label string
14087                         Size  uint16
14088                         Texture
14089                         Scale uint16
14090                 }))(obj)).Type).Serialize(w)
14091         }); err != nil {
14092                 if err == io.EOF {
14093                         chk(io.EOF)
14094                 }
14095                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MinimapType", err))
14096         }
14097         if len(([]byte((*(*(struct {
14098                 Type  MinimapType
14099                 Label string
14100                 Size  uint16
14101                 Texture
14102                 Scale uint16
14103         }))(obj)).Label))) > math.MaxUint16 {
14104                 chk(ErrTooLong)
14105         }
14106         {
14107                 x := uint16(len(([]byte((*(*(struct {
14108                         Type  MinimapType
14109                         Label string
14110                         Size  uint16
14111                         Texture
14112                         Scale uint16
14113                 }))(obj)).Label))))
14114                 write16(w, uint16(x))
14115         }
14116         {
14117                 _, err := w.Write(([]byte((*(*(struct {
14118                         Type  MinimapType
14119                         Label string
14120                         Size  uint16
14121                         Texture
14122                         Scale uint16
14123                 }))(obj)).Label))[:])
14124                 chk(err)
14125         }
14126         {
14127                 x := (*(*(struct {
14128                         Type  MinimapType
14129                         Label string
14130                         Size  uint16
14131                         Texture
14132                         Scale uint16
14133                 }))(obj)).Size
14134                 write16(w, uint16(x))
14135         }
14136         if err := pcall(func() {
14137                 ((*(*(struct {
14138                         Type  MinimapType
14139                         Label string
14140                         Size  uint16
14141                         Texture
14142                         Scale uint16
14143                 }))(obj)).Texture).Serialize(w)
14144         }); err != nil {
14145                 if err == io.EOF {
14146                         chk(io.EOF)
14147                 }
14148                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
14149         }
14150         {
14151                 x := (*(*(struct {
14152                         Type  MinimapType
14153                         Label string
14154                         Size  uint16
14155                         Texture
14156                         Scale uint16
14157                 }))(obj)).Scale
14158                 write16(w, uint16(x))
14159         }
14160 }
14161
14162 func (obj *MinimapMode) Deserialize(r io.Reader) {
14163         if err := pcall(func() {
14164                 ((*(*(struct {
14165                         Type  MinimapType
14166                         Label string
14167                         Size  uint16
14168                         Texture
14169                         Scale uint16
14170                 }))(obj)).Type).Deserialize(r)
14171         }); err != nil {
14172                 if err == io.EOF {
14173                         chk(io.EOF)
14174                 }
14175                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MinimapType", err))
14176         }
14177         var local236 []uint8
14178         var local237 uint16
14179         {
14180                 p := &local237
14181                 *p = read16(r)
14182         }
14183         (local236) = make([]uint8, local237)
14184         {
14185                 _, err := io.ReadFull(r, (local236)[:])
14186                 chk(err)
14187         }
14188         ((*(*(struct {
14189                 Type  MinimapType
14190                 Label string
14191                 Size  uint16
14192                 Texture
14193                 Scale uint16
14194         }))(obj)).Label) = string(local236)
14195         {
14196                 p := &(*(*(struct {
14197                         Type  MinimapType
14198                         Label string
14199                         Size  uint16
14200                         Texture
14201                         Scale uint16
14202                 }))(obj)).Size
14203                 *p = read16(r)
14204         }
14205         if err := pcall(func() {
14206                 ((*(*(struct {
14207                         Type  MinimapType
14208                         Label string
14209                         Size  uint16
14210                         Texture
14211                         Scale uint16
14212                 }))(obj)).Texture).Deserialize(r)
14213         }); err != nil {
14214                 if err == io.EOF {
14215                         chk(io.EOF)
14216                 }
14217                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
14218         }
14219         {
14220                 p := &(*(*(struct {
14221                         Type  MinimapType
14222                         Label string
14223                         Size  uint16
14224                         Texture
14225                         Scale uint16
14226                 }))(obj)).Scale
14227                 *p = read16(r)
14228         }
14229 }
14230
14231 func (obj *NodeDef) Serialize(w io.Writer) {
14232         if err := pcall(func() {
14233                 ((*(*(struct {
14234                         Param0 Content
14235
14236                         Name   string
14237                         Groups []Group
14238
14239                         P1Type   Param1Type
14240                         P2Type   Param2Type
14241                         DrawType DrawType
14242
14243                         Mesh  string
14244                         Scale float32
14245                         //mt:const uint8(6)
14246                         Tiles        [6]TileDef
14247                         OverlayTiles [6]TileDef
14248                         //mt:const uint8(6)
14249                         SpecialTiles [6]TileDef
14250
14251                         Color   color.NRGBA
14252                         Palette Texture
14253
14254                         Waving       WaveType
14255                         ConnectSides uint8
14256                         ConnectTo    []Content
14257                         InsideTint   color.NRGBA
14258                         Level        uint8 // Must be < 128.
14259
14260                         Translucent bool // Sunlight is scattered and becomes normal light.
14261                         Transparent bool // Sunlight isn't scattered.
14262                         LightSrc    uint8
14263
14264                         GndContent   bool
14265                         Collides     bool
14266                         Pointable    bool
14267                         Diggable     bool
14268                         Climbable    bool
14269                         Replaceable  bool
14270                         OnRightClick bool
14271
14272                         DmgPerSec int32
14273
14274                         LiquidType   LiquidType
14275                         FlowingAlt   string
14276                         SrcAlt       string
14277                         Viscosity    uint8 // 0-7
14278                         LiqRenewable bool
14279                         FlowRange    uint8
14280                         DrownDmg     uint8
14281                         Floodable    bool
14282
14283                         DrawBox, ColBox, SelBox NodeBox
14284
14285                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14286
14287                         LegacyFaceDir bool
14288                         LegacyMounted bool
14289
14290                         DigPredict string
14291
14292                         MaxLvl uint8
14293
14294                         AlphaUse
14295
14296                         MoveResistance uint8
14297
14298                         LiquidMovePhysics bool
14299                 }))(obj)).Param0).Serialize(w)
14300         }); err != nil {
14301                 if err == io.EOF {
14302                         chk(io.EOF)
14303                 }
14304                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
14305         }
14306         {
14307                 ow := w
14308                 w := new(bytes.Buffer)
14309                 {
14310                         local238 := uint8(13)
14311                         {
14312                                 x := local238
14313                                 write8(w, uint8(x))
14314                         }
14315                 }
14316                 if len(([]byte((*(*(struct {
14317                         Param0 Content
14318
14319                         Name   string
14320                         Groups []Group
14321
14322                         P1Type   Param1Type
14323                         P2Type   Param2Type
14324                         DrawType DrawType
14325
14326                         Mesh  string
14327                         Scale float32
14328                         //mt:const uint8(6)
14329                         Tiles        [6]TileDef
14330                         OverlayTiles [6]TileDef
14331                         //mt:const uint8(6)
14332                         SpecialTiles [6]TileDef
14333
14334                         Color   color.NRGBA
14335                         Palette Texture
14336
14337                         Waving       WaveType
14338                         ConnectSides uint8
14339                         ConnectTo    []Content
14340                         InsideTint   color.NRGBA
14341                         Level        uint8 // Must be < 128.
14342
14343                         Translucent bool // Sunlight is scattered and becomes normal light.
14344                         Transparent bool // Sunlight isn't scattered.
14345                         LightSrc    uint8
14346
14347                         GndContent   bool
14348                         Collides     bool
14349                         Pointable    bool
14350                         Diggable     bool
14351                         Climbable    bool
14352                         Replaceable  bool
14353                         OnRightClick bool
14354
14355                         DmgPerSec int32
14356
14357                         LiquidType   LiquidType
14358                         FlowingAlt   string
14359                         SrcAlt       string
14360                         Viscosity    uint8 // 0-7
14361                         LiqRenewable bool
14362                         FlowRange    uint8
14363                         DrownDmg     uint8
14364                         Floodable    bool
14365
14366                         DrawBox, ColBox, SelBox NodeBox
14367
14368                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14369
14370                         LegacyFaceDir bool
14371                         LegacyMounted bool
14372
14373                         DigPredict string
14374
14375                         MaxLvl uint8
14376
14377                         AlphaUse
14378
14379                         MoveResistance uint8
14380
14381                         LiquidMovePhysics bool
14382                 }))(obj)).Name))) > math.MaxUint16 {
14383                         chk(ErrTooLong)
14384                 }
14385                 {
14386                         x := uint16(len(([]byte((*(*(struct {
14387                                 Param0 Content
14388
14389                                 Name   string
14390                                 Groups []Group
14391
14392                                 P1Type   Param1Type
14393                                 P2Type   Param2Type
14394                                 DrawType DrawType
14395
14396                                 Mesh  string
14397                                 Scale float32
14398                                 //mt:const uint8(6)
14399                                 Tiles        [6]TileDef
14400                                 OverlayTiles [6]TileDef
14401                                 //mt:const uint8(6)
14402                                 SpecialTiles [6]TileDef
14403
14404                                 Color   color.NRGBA
14405                                 Palette Texture
14406
14407                                 Waving       WaveType
14408                                 ConnectSides uint8
14409                                 ConnectTo    []Content
14410                                 InsideTint   color.NRGBA
14411                                 Level        uint8 // Must be < 128.
14412
14413                                 Translucent bool // Sunlight is scattered and becomes normal light.
14414                                 Transparent bool // Sunlight isn't scattered.
14415                                 LightSrc    uint8
14416
14417                                 GndContent   bool
14418                                 Collides     bool
14419                                 Pointable    bool
14420                                 Diggable     bool
14421                                 Climbable    bool
14422                                 Replaceable  bool
14423                                 OnRightClick bool
14424
14425                                 DmgPerSec int32
14426
14427                                 LiquidType   LiquidType
14428                                 FlowingAlt   string
14429                                 SrcAlt       string
14430                                 Viscosity    uint8 // 0-7
14431                                 LiqRenewable bool
14432                                 FlowRange    uint8
14433                                 DrownDmg     uint8
14434                                 Floodable    bool
14435
14436                                 DrawBox, ColBox, SelBox NodeBox
14437
14438                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14439
14440                                 LegacyFaceDir bool
14441                                 LegacyMounted bool
14442
14443                                 DigPredict string
14444
14445                                 MaxLvl uint8
14446
14447                                 AlphaUse
14448
14449                                 MoveResistance uint8
14450
14451                                 LiquidMovePhysics bool
14452                         }))(obj)).Name))))
14453                         write16(w, uint16(x))
14454                 }
14455                 {
14456                         _, err := w.Write(([]byte((*(*(struct {
14457                                 Param0 Content
14458
14459                                 Name   string
14460                                 Groups []Group
14461
14462                                 P1Type   Param1Type
14463                                 P2Type   Param2Type
14464                                 DrawType DrawType
14465
14466                                 Mesh  string
14467                                 Scale float32
14468                                 //mt:const uint8(6)
14469                                 Tiles        [6]TileDef
14470                                 OverlayTiles [6]TileDef
14471                                 //mt:const uint8(6)
14472                                 SpecialTiles [6]TileDef
14473
14474                                 Color   color.NRGBA
14475                                 Palette Texture
14476
14477                                 Waving       WaveType
14478                                 ConnectSides uint8
14479                                 ConnectTo    []Content
14480                                 InsideTint   color.NRGBA
14481                                 Level        uint8 // Must be < 128.
14482
14483                                 Translucent bool // Sunlight is scattered and becomes normal light.
14484                                 Transparent bool // Sunlight isn't scattered.
14485                                 LightSrc    uint8
14486
14487                                 GndContent   bool
14488                                 Collides     bool
14489                                 Pointable    bool
14490                                 Diggable     bool
14491                                 Climbable    bool
14492                                 Replaceable  bool
14493                                 OnRightClick bool
14494
14495                                 DmgPerSec int32
14496
14497                                 LiquidType   LiquidType
14498                                 FlowingAlt   string
14499                                 SrcAlt       string
14500                                 Viscosity    uint8 // 0-7
14501                                 LiqRenewable bool
14502                                 FlowRange    uint8
14503                                 DrownDmg     uint8
14504                                 Floodable    bool
14505
14506                                 DrawBox, ColBox, SelBox NodeBox
14507
14508                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14509
14510                                 LegacyFaceDir bool
14511                                 LegacyMounted bool
14512
14513                                 DigPredict string
14514
14515                                 MaxLvl uint8
14516
14517                                 AlphaUse
14518
14519                                 MoveResistance uint8
14520
14521                                 LiquidMovePhysics bool
14522                         }))(obj)).Name))[:])
14523                         chk(err)
14524                 }
14525                 if len(((*(*(struct {
14526                         Param0 Content
14527
14528                         Name   string
14529                         Groups []Group
14530
14531                         P1Type   Param1Type
14532                         P2Type   Param2Type
14533                         DrawType DrawType
14534
14535                         Mesh  string
14536                         Scale float32
14537                         //mt:const uint8(6)
14538                         Tiles        [6]TileDef
14539                         OverlayTiles [6]TileDef
14540                         //mt:const uint8(6)
14541                         SpecialTiles [6]TileDef
14542
14543                         Color   color.NRGBA
14544                         Palette Texture
14545
14546                         Waving       WaveType
14547                         ConnectSides uint8
14548                         ConnectTo    []Content
14549                         InsideTint   color.NRGBA
14550                         Level        uint8 // Must be < 128.
14551
14552                         Translucent bool // Sunlight is scattered and becomes normal light.
14553                         Transparent bool // Sunlight isn't scattered.
14554                         LightSrc    uint8
14555
14556                         GndContent   bool
14557                         Collides     bool
14558                         Pointable    bool
14559                         Diggable     bool
14560                         Climbable    bool
14561                         Replaceable  bool
14562                         OnRightClick bool
14563
14564                         DmgPerSec int32
14565
14566                         LiquidType   LiquidType
14567                         FlowingAlt   string
14568                         SrcAlt       string
14569                         Viscosity    uint8 // 0-7
14570                         LiqRenewable bool
14571                         FlowRange    uint8
14572                         DrownDmg     uint8
14573                         Floodable    bool
14574
14575                         DrawBox, ColBox, SelBox NodeBox
14576
14577                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14578
14579                         LegacyFaceDir bool
14580                         LegacyMounted bool
14581
14582                         DigPredict string
14583
14584                         MaxLvl uint8
14585
14586                         AlphaUse
14587
14588                         MoveResistance uint8
14589
14590                         LiquidMovePhysics bool
14591                 }))(obj)).Groups)) > math.MaxUint16 {
14592                         chk(ErrTooLong)
14593                 }
14594                 {
14595                         x := uint16(len(((*(*(struct {
14596                                 Param0 Content
14597
14598                                 Name   string
14599                                 Groups []Group
14600
14601                                 P1Type   Param1Type
14602                                 P2Type   Param2Type
14603                                 DrawType DrawType
14604
14605                                 Mesh  string
14606                                 Scale float32
14607                                 //mt:const uint8(6)
14608                                 Tiles        [6]TileDef
14609                                 OverlayTiles [6]TileDef
14610                                 //mt:const uint8(6)
14611                                 SpecialTiles [6]TileDef
14612
14613                                 Color   color.NRGBA
14614                                 Palette Texture
14615
14616                                 Waving       WaveType
14617                                 ConnectSides uint8
14618                                 ConnectTo    []Content
14619                                 InsideTint   color.NRGBA
14620                                 Level        uint8 // Must be < 128.
14621
14622                                 Translucent bool // Sunlight is scattered and becomes normal light.
14623                                 Transparent bool // Sunlight isn't scattered.
14624                                 LightSrc    uint8
14625
14626                                 GndContent   bool
14627                                 Collides     bool
14628                                 Pointable    bool
14629                                 Diggable     bool
14630                                 Climbable    bool
14631                                 Replaceable  bool
14632                                 OnRightClick bool
14633
14634                                 DmgPerSec int32
14635
14636                                 LiquidType   LiquidType
14637                                 FlowingAlt   string
14638                                 SrcAlt       string
14639                                 Viscosity    uint8 // 0-7
14640                                 LiqRenewable bool
14641                                 FlowRange    uint8
14642                                 DrownDmg     uint8
14643                                 Floodable    bool
14644
14645                                 DrawBox, ColBox, SelBox NodeBox
14646
14647                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14648
14649                                 LegacyFaceDir bool
14650                                 LegacyMounted bool
14651
14652                                 DigPredict string
14653
14654                                 MaxLvl uint8
14655
14656                                 AlphaUse
14657
14658                                 MoveResistance uint8
14659
14660                                 LiquidMovePhysics bool
14661                         }))(obj)).Groups)))
14662                         write16(w, uint16(x))
14663                 }
14664                 for local239 := range (*(*(struct {
14665                         Param0 Content
14666
14667                         Name   string
14668                         Groups []Group
14669
14670                         P1Type   Param1Type
14671                         P2Type   Param2Type
14672                         DrawType DrawType
14673
14674                         Mesh  string
14675                         Scale float32
14676                         //mt:const uint8(6)
14677                         Tiles        [6]TileDef
14678                         OverlayTiles [6]TileDef
14679                         //mt:const uint8(6)
14680                         SpecialTiles [6]TileDef
14681
14682                         Color   color.NRGBA
14683                         Palette Texture
14684
14685                         Waving       WaveType
14686                         ConnectSides uint8
14687                         ConnectTo    []Content
14688                         InsideTint   color.NRGBA
14689                         Level        uint8 // Must be < 128.
14690
14691                         Translucent bool // Sunlight is scattered and becomes normal light.
14692                         Transparent bool // Sunlight isn't scattered.
14693                         LightSrc    uint8
14694
14695                         GndContent   bool
14696                         Collides     bool
14697                         Pointable    bool
14698                         Diggable     bool
14699                         Climbable    bool
14700                         Replaceable  bool
14701                         OnRightClick bool
14702
14703                         DmgPerSec int32
14704
14705                         LiquidType   LiquidType
14706                         FlowingAlt   string
14707                         SrcAlt       string
14708                         Viscosity    uint8 // 0-7
14709                         LiqRenewable bool
14710                         FlowRange    uint8
14711                         DrownDmg     uint8
14712                         Floodable    bool
14713
14714                         DrawBox, ColBox, SelBox NodeBox
14715
14716                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14717
14718                         LegacyFaceDir bool
14719                         LegacyMounted bool
14720
14721                         DigPredict string
14722
14723                         MaxLvl uint8
14724
14725                         AlphaUse
14726
14727                         MoveResistance uint8
14728
14729                         LiquidMovePhysics bool
14730                 }))(obj)).Groups {
14731                         if err := pcall(func() {
14732                                 (((*(*(struct {
14733                                         Param0 Content
14734
14735                                         Name   string
14736                                         Groups []Group
14737
14738                                         P1Type   Param1Type
14739                                         P2Type   Param2Type
14740                                         DrawType DrawType
14741
14742                                         Mesh  string
14743                                         Scale float32
14744                                         //mt:const uint8(6)
14745                                         Tiles        [6]TileDef
14746                                         OverlayTiles [6]TileDef
14747                                         //mt:const uint8(6)
14748                                         SpecialTiles [6]TileDef
14749
14750                                         Color   color.NRGBA
14751                                         Palette Texture
14752
14753                                         Waving       WaveType
14754                                         ConnectSides uint8
14755                                         ConnectTo    []Content
14756                                         InsideTint   color.NRGBA
14757                                         Level        uint8 // Must be < 128.
14758
14759                                         Translucent bool // Sunlight is scattered and becomes normal light.
14760                                         Transparent bool // Sunlight isn't scattered.
14761                                         LightSrc    uint8
14762
14763                                         GndContent   bool
14764                                         Collides     bool
14765                                         Pointable    bool
14766                                         Diggable     bool
14767                                         Climbable    bool
14768                                         Replaceable  bool
14769                                         OnRightClick bool
14770
14771                                         DmgPerSec int32
14772
14773                                         LiquidType   LiquidType
14774                                         FlowingAlt   string
14775                                         SrcAlt       string
14776                                         Viscosity    uint8 // 0-7
14777                                         LiqRenewable bool
14778                                         FlowRange    uint8
14779                                         DrownDmg     uint8
14780                                         Floodable    bool
14781
14782                                         DrawBox, ColBox, SelBox NodeBox
14783
14784                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14785
14786                                         LegacyFaceDir bool
14787                                         LegacyMounted bool
14788
14789                                         DigPredict string
14790
14791                                         MaxLvl uint8
14792
14793                                         AlphaUse
14794
14795                                         MoveResistance uint8
14796
14797                                         LiquidMovePhysics bool
14798                                 }))(obj)).Groups)[local239]).Serialize(w)
14799                         }); err != nil {
14800                                 if err == io.EOF {
14801                                         chk(io.EOF)
14802                                 }
14803                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
14804                         }
14805                 }
14806                 if err := pcall(func() {
14807                         ((*(*(struct {
14808                                 Param0 Content
14809
14810                                 Name   string
14811                                 Groups []Group
14812
14813                                 P1Type   Param1Type
14814                                 P2Type   Param2Type
14815                                 DrawType DrawType
14816
14817                                 Mesh  string
14818                                 Scale float32
14819                                 //mt:const uint8(6)
14820                                 Tiles        [6]TileDef
14821                                 OverlayTiles [6]TileDef
14822                                 //mt:const uint8(6)
14823                                 SpecialTiles [6]TileDef
14824
14825                                 Color   color.NRGBA
14826                                 Palette Texture
14827
14828                                 Waving       WaveType
14829                                 ConnectSides uint8
14830                                 ConnectTo    []Content
14831                                 InsideTint   color.NRGBA
14832                                 Level        uint8 // Must be < 128.
14833
14834                                 Translucent bool // Sunlight is scattered and becomes normal light.
14835                                 Transparent bool // Sunlight isn't scattered.
14836                                 LightSrc    uint8
14837
14838                                 GndContent   bool
14839                                 Collides     bool
14840                                 Pointable    bool
14841                                 Diggable     bool
14842                                 Climbable    bool
14843                                 Replaceable  bool
14844                                 OnRightClick bool
14845
14846                                 DmgPerSec int32
14847
14848                                 LiquidType   LiquidType
14849                                 FlowingAlt   string
14850                                 SrcAlt       string
14851                                 Viscosity    uint8 // 0-7
14852                                 LiqRenewable bool
14853                                 FlowRange    uint8
14854                                 DrownDmg     uint8
14855                                 Floodable    bool
14856
14857                                 DrawBox, ColBox, SelBox NodeBox
14858
14859                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14860
14861                                 LegacyFaceDir bool
14862                                 LegacyMounted bool
14863
14864                                 DigPredict string
14865
14866                                 MaxLvl uint8
14867
14868                                 AlphaUse
14869
14870                                 MoveResistance uint8
14871
14872                                 LiquidMovePhysics bool
14873                         }))(obj)).P1Type).Serialize(w)
14874                 }); err != nil {
14875                         if err == io.EOF {
14876                                 chk(io.EOF)
14877                         }
14878                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param1Type", err))
14879                 }
14880                 if err := pcall(func() {
14881                         ((*(*(struct {
14882                                 Param0 Content
14883
14884                                 Name   string
14885                                 Groups []Group
14886
14887                                 P1Type   Param1Type
14888                                 P2Type   Param2Type
14889                                 DrawType DrawType
14890
14891                                 Mesh  string
14892                                 Scale float32
14893                                 //mt:const uint8(6)
14894                                 Tiles        [6]TileDef
14895                                 OverlayTiles [6]TileDef
14896                                 //mt:const uint8(6)
14897                                 SpecialTiles [6]TileDef
14898
14899                                 Color   color.NRGBA
14900                                 Palette Texture
14901
14902                                 Waving       WaveType
14903                                 ConnectSides uint8
14904                                 ConnectTo    []Content
14905                                 InsideTint   color.NRGBA
14906                                 Level        uint8 // Must be < 128.
14907
14908                                 Translucent bool // Sunlight is scattered and becomes normal light.
14909                                 Transparent bool // Sunlight isn't scattered.
14910                                 LightSrc    uint8
14911
14912                                 GndContent   bool
14913                                 Collides     bool
14914                                 Pointable    bool
14915                                 Diggable     bool
14916                                 Climbable    bool
14917                                 Replaceable  bool
14918                                 OnRightClick bool
14919
14920                                 DmgPerSec int32
14921
14922                                 LiquidType   LiquidType
14923                                 FlowingAlt   string
14924                                 SrcAlt       string
14925                                 Viscosity    uint8 // 0-7
14926                                 LiqRenewable bool
14927                                 FlowRange    uint8
14928                                 DrownDmg     uint8
14929                                 Floodable    bool
14930
14931                                 DrawBox, ColBox, SelBox NodeBox
14932
14933                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14934
14935                                 LegacyFaceDir bool
14936                                 LegacyMounted bool
14937
14938                                 DigPredict string
14939
14940                                 MaxLvl uint8
14941
14942                                 AlphaUse
14943
14944                                 MoveResistance uint8
14945
14946                                 LiquidMovePhysics bool
14947                         }))(obj)).P2Type).Serialize(w)
14948                 }); err != nil {
14949                         if err == io.EOF {
14950                                 chk(io.EOF)
14951                         }
14952                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param2Type", err))
14953                 }
14954                 if err := pcall(func() {
14955                         ((*(*(struct {
14956                                 Param0 Content
14957
14958                                 Name   string
14959                                 Groups []Group
14960
14961                                 P1Type   Param1Type
14962                                 P2Type   Param2Type
14963                                 DrawType DrawType
14964
14965                                 Mesh  string
14966                                 Scale float32
14967                                 //mt:const uint8(6)
14968                                 Tiles        [6]TileDef
14969                                 OverlayTiles [6]TileDef
14970                                 //mt:const uint8(6)
14971                                 SpecialTiles [6]TileDef
14972
14973                                 Color   color.NRGBA
14974                                 Palette Texture
14975
14976                                 Waving       WaveType
14977                                 ConnectSides uint8
14978                                 ConnectTo    []Content
14979                                 InsideTint   color.NRGBA
14980                                 Level        uint8 // Must be < 128.
14981
14982                                 Translucent bool // Sunlight is scattered and becomes normal light.
14983                                 Transparent bool // Sunlight isn't scattered.
14984                                 LightSrc    uint8
14985
14986                                 GndContent   bool
14987                                 Collides     bool
14988                                 Pointable    bool
14989                                 Diggable     bool
14990                                 Climbable    bool
14991                                 Replaceable  bool
14992                                 OnRightClick bool
14993
14994                                 DmgPerSec int32
14995
14996                                 LiquidType   LiquidType
14997                                 FlowingAlt   string
14998                                 SrcAlt       string
14999                                 Viscosity    uint8 // 0-7
15000                                 LiqRenewable bool
15001                                 FlowRange    uint8
15002                                 DrownDmg     uint8
15003                                 Floodable    bool
15004
15005                                 DrawBox, ColBox, SelBox NodeBox
15006
15007                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15008
15009                                 LegacyFaceDir bool
15010                                 LegacyMounted bool
15011
15012                                 DigPredict string
15013
15014                                 MaxLvl uint8
15015
15016                                 AlphaUse
15017
15018                                 MoveResistance uint8
15019
15020                                 LiquidMovePhysics bool
15021                         }))(obj)).DrawType).Serialize(w)
15022                 }); err != nil {
15023                         if err == io.EOF {
15024                                 chk(io.EOF)
15025                         }
15026                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DrawType", err))
15027                 }
15028                 if len(([]byte((*(*(struct {
15029                         Param0 Content
15030
15031                         Name   string
15032                         Groups []Group
15033
15034                         P1Type   Param1Type
15035                         P2Type   Param2Type
15036                         DrawType DrawType
15037
15038                         Mesh  string
15039                         Scale float32
15040                         //mt:const uint8(6)
15041                         Tiles        [6]TileDef
15042                         OverlayTiles [6]TileDef
15043                         //mt:const uint8(6)
15044                         SpecialTiles [6]TileDef
15045
15046                         Color   color.NRGBA
15047                         Palette Texture
15048
15049                         Waving       WaveType
15050                         ConnectSides uint8
15051                         ConnectTo    []Content
15052                         InsideTint   color.NRGBA
15053                         Level        uint8 // Must be < 128.
15054
15055                         Translucent bool // Sunlight is scattered and becomes normal light.
15056                         Transparent bool // Sunlight isn't scattered.
15057                         LightSrc    uint8
15058
15059                         GndContent   bool
15060                         Collides     bool
15061                         Pointable    bool
15062                         Diggable     bool
15063                         Climbable    bool
15064                         Replaceable  bool
15065                         OnRightClick bool
15066
15067                         DmgPerSec int32
15068
15069                         LiquidType   LiquidType
15070                         FlowingAlt   string
15071                         SrcAlt       string
15072                         Viscosity    uint8 // 0-7
15073                         LiqRenewable bool
15074                         FlowRange    uint8
15075                         DrownDmg     uint8
15076                         Floodable    bool
15077
15078                         DrawBox, ColBox, SelBox NodeBox
15079
15080                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15081
15082                         LegacyFaceDir bool
15083                         LegacyMounted bool
15084
15085                         DigPredict string
15086
15087                         MaxLvl uint8
15088
15089                         AlphaUse
15090
15091                         MoveResistance uint8
15092
15093                         LiquidMovePhysics bool
15094                 }))(obj)).Mesh))) > math.MaxUint16 {
15095                         chk(ErrTooLong)
15096                 }
15097                 {
15098                         x := uint16(len(([]byte((*(*(struct {
15099                                 Param0 Content
15100
15101                                 Name   string
15102                                 Groups []Group
15103
15104                                 P1Type   Param1Type
15105                                 P2Type   Param2Type
15106                                 DrawType DrawType
15107
15108                                 Mesh  string
15109                                 Scale float32
15110                                 //mt:const uint8(6)
15111                                 Tiles        [6]TileDef
15112                                 OverlayTiles [6]TileDef
15113                                 //mt:const uint8(6)
15114                                 SpecialTiles [6]TileDef
15115
15116                                 Color   color.NRGBA
15117                                 Palette Texture
15118
15119                                 Waving       WaveType
15120                                 ConnectSides uint8
15121                                 ConnectTo    []Content
15122                                 InsideTint   color.NRGBA
15123                                 Level        uint8 // Must be < 128.
15124
15125                                 Translucent bool // Sunlight is scattered and becomes normal light.
15126                                 Transparent bool // Sunlight isn't scattered.
15127                                 LightSrc    uint8
15128
15129                                 GndContent   bool
15130                                 Collides     bool
15131                                 Pointable    bool
15132                                 Diggable     bool
15133                                 Climbable    bool
15134                                 Replaceable  bool
15135                                 OnRightClick bool
15136
15137                                 DmgPerSec int32
15138
15139                                 LiquidType   LiquidType
15140                                 FlowingAlt   string
15141                                 SrcAlt       string
15142                                 Viscosity    uint8 // 0-7
15143                                 LiqRenewable bool
15144                                 FlowRange    uint8
15145                                 DrownDmg     uint8
15146                                 Floodable    bool
15147
15148                                 DrawBox, ColBox, SelBox NodeBox
15149
15150                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15151
15152                                 LegacyFaceDir bool
15153                                 LegacyMounted bool
15154
15155                                 DigPredict string
15156
15157                                 MaxLvl uint8
15158
15159                                 AlphaUse
15160
15161                                 MoveResistance uint8
15162
15163                                 LiquidMovePhysics bool
15164                         }))(obj)).Mesh))))
15165                         write16(w, uint16(x))
15166                 }
15167                 {
15168                         _, err := w.Write(([]byte((*(*(struct {
15169                                 Param0 Content
15170
15171                                 Name   string
15172                                 Groups []Group
15173
15174                                 P1Type   Param1Type
15175                                 P2Type   Param2Type
15176                                 DrawType DrawType
15177
15178                                 Mesh  string
15179                                 Scale float32
15180                                 //mt:const uint8(6)
15181                                 Tiles        [6]TileDef
15182                                 OverlayTiles [6]TileDef
15183                                 //mt:const uint8(6)
15184                                 SpecialTiles [6]TileDef
15185
15186                                 Color   color.NRGBA
15187                                 Palette Texture
15188
15189                                 Waving       WaveType
15190                                 ConnectSides uint8
15191                                 ConnectTo    []Content
15192                                 InsideTint   color.NRGBA
15193                                 Level        uint8 // Must be < 128.
15194
15195                                 Translucent bool // Sunlight is scattered and becomes normal light.
15196                                 Transparent bool // Sunlight isn't scattered.
15197                                 LightSrc    uint8
15198
15199                                 GndContent   bool
15200                                 Collides     bool
15201                                 Pointable    bool
15202                                 Diggable     bool
15203                                 Climbable    bool
15204                                 Replaceable  bool
15205                                 OnRightClick bool
15206
15207                                 DmgPerSec int32
15208
15209                                 LiquidType   LiquidType
15210                                 FlowingAlt   string
15211                                 SrcAlt       string
15212                                 Viscosity    uint8 // 0-7
15213                                 LiqRenewable bool
15214                                 FlowRange    uint8
15215                                 DrownDmg     uint8
15216                                 Floodable    bool
15217
15218                                 DrawBox, ColBox, SelBox NodeBox
15219
15220                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15221
15222                                 LegacyFaceDir bool
15223                                 LegacyMounted bool
15224
15225                                 DigPredict string
15226
15227                                 MaxLvl uint8
15228
15229                                 AlphaUse
15230
15231                                 MoveResistance uint8
15232
15233                                 LiquidMovePhysics bool
15234                         }))(obj)).Mesh))[:])
15235                         chk(err)
15236                 }
15237                 {
15238                         x := (*(*(struct {
15239                                 Param0 Content
15240
15241                                 Name   string
15242                                 Groups []Group
15243
15244                                 P1Type   Param1Type
15245                                 P2Type   Param2Type
15246                                 DrawType DrawType
15247
15248                                 Mesh  string
15249                                 Scale float32
15250                                 //mt:const uint8(6)
15251                                 Tiles        [6]TileDef
15252                                 OverlayTiles [6]TileDef
15253                                 //mt:const uint8(6)
15254                                 SpecialTiles [6]TileDef
15255
15256                                 Color   color.NRGBA
15257                                 Palette Texture
15258
15259                                 Waving       WaveType
15260                                 ConnectSides uint8
15261                                 ConnectTo    []Content
15262                                 InsideTint   color.NRGBA
15263                                 Level        uint8 // Must be < 128.
15264
15265                                 Translucent bool // Sunlight is scattered and becomes normal light.
15266                                 Transparent bool // Sunlight isn't scattered.
15267                                 LightSrc    uint8
15268
15269                                 GndContent   bool
15270                                 Collides     bool
15271                                 Pointable    bool
15272                                 Diggable     bool
15273                                 Climbable    bool
15274                                 Replaceable  bool
15275                                 OnRightClick bool
15276
15277                                 DmgPerSec int32
15278
15279                                 LiquidType   LiquidType
15280                                 FlowingAlt   string
15281                                 SrcAlt       string
15282                                 Viscosity    uint8 // 0-7
15283                                 LiqRenewable bool
15284                                 FlowRange    uint8
15285                                 DrownDmg     uint8
15286                                 Floodable    bool
15287
15288                                 DrawBox, ColBox, SelBox NodeBox
15289
15290                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15291
15292                                 LegacyFaceDir bool
15293                                 LegacyMounted bool
15294
15295                                 DigPredict string
15296
15297                                 MaxLvl uint8
15298
15299                                 AlphaUse
15300
15301                                 MoveResistance uint8
15302
15303                                 LiquidMovePhysics bool
15304                         }))(obj)).Scale
15305                         write32(w, math.Float32bits(x))
15306                 }
15307                 {
15308                         local240 := uint8(6)
15309                         {
15310                                 x := local240
15311                                 write8(w, uint8(x))
15312                         }
15313                 }
15314                 for local241 := range (*(*(struct {
15315                         Param0 Content
15316
15317                         Name   string
15318                         Groups []Group
15319
15320                         P1Type   Param1Type
15321                         P2Type   Param2Type
15322                         DrawType DrawType
15323
15324                         Mesh  string
15325                         Scale float32
15326                         //mt:const uint8(6)
15327                         Tiles        [6]TileDef
15328                         OverlayTiles [6]TileDef
15329                         //mt:const uint8(6)
15330                         SpecialTiles [6]TileDef
15331
15332                         Color   color.NRGBA
15333                         Palette Texture
15334
15335                         Waving       WaveType
15336                         ConnectSides uint8
15337                         ConnectTo    []Content
15338                         InsideTint   color.NRGBA
15339                         Level        uint8 // Must be < 128.
15340
15341                         Translucent bool // Sunlight is scattered and becomes normal light.
15342                         Transparent bool // Sunlight isn't scattered.
15343                         LightSrc    uint8
15344
15345                         GndContent   bool
15346                         Collides     bool
15347                         Pointable    bool
15348                         Diggable     bool
15349                         Climbable    bool
15350                         Replaceable  bool
15351                         OnRightClick bool
15352
15353                         DmgPerSec int32
15354
15355                         LiquidType   LiquidType
15356                         FlowingAlt   string
15357                         SrcAlt       string
15358                         Viscosity    uint8 // 0-7
15359                         LiqRenewable bool
15360                         FlowRange    uint8
15361                         DrownDmg     uint8
15362                         Floodable    bool
15363
15364                         DrawBox, ColBox, SelBox NodeBox
15365
15366                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15367
15368                         LegacyFaceDir bool
15369                         LegacyMounted bool
15370
15371                         DigPredict string
15372
15373                         MaxLvl uint8
15374
15375                         AlphaUse
15376
15377                         MoveResistance uint8
15378
15379                         LiquidMovePhysics bool
15380                 }))(obj)).Tiles {
15381                         if err := pcall(func() {
15382                                 (((*(*(struct {
15383                                         Param0 Content
15384
15385                                         Name   string
15386                                         Groups []Group
15387
15388                                         P1Type   Param1Type
15389                                         P2Type   Param2Type
15390                                         DrawType DrawType
15391
15392                                         Mesh  string
15393                                         Scale float32
15394                                         //mt:const uint8(6)
15395                                         Tiles        [6]TileDef
15396                                         OverlayTiles [6]TileDef
15397                                         //mt:const uint8(6)
15398                                         SpecialTiles [6]TileDef
15399
15400                                         Color   color.NRGBA
15401                                         Palette Texture
15402
15403                                         Waving       WaveType
15404                                         ConnectSides uint8
15405                                         ConnectTo    []Content
15406                                         InsideTint   color.NRGBA
15407                                         Level        uint8 // Must be < 128.
15408
15409                                         Translucent bool // Sunlight is scattered and becomes normal light.
15410                                         Transparent bool // Sunlight isn't scattered.
15411                                         LightSrc    uint8
15412
15413                                         GndContent   bool
15414                                         Collides     bool
15415                                         Pointable    bool
15416                                         Diggable     bool
15417                                         Climbable    bool
15418                                         Replaceable  bool
15419                                         OnRightClick bool
15420
15421                                         DmgPerSec int32
15422
15423                                         LiquidType   LiquidType
15424                                         FlowingAlt   string
15425                                         SrcAlt       string
15426                                         Viscosity    uint8 // 0-7
15427                                         LiqRenewable bool
15428                                         FlowRange    uint8
15429                                         DrownDmg     uint8
15430                                         Floodable    bool
15431
15432                                         DrawBox, ColBox, SelBox NodeBox
15433
15434                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15435
15436                                         LegacyFaceDir bool
15437                                         LegacyMounted bool
15438
15439                                         DigPredict string
15440
15441                                         MaxLvl uint8
15442
15443                                         AlphaUse
15444
15445                                         MoveResistance uint8
15446
15447                                         LiquidMovePhysics bool
15448                                 }))(obj)).Tiles)[local241]).Serialize(w)
15449                         }); err != nil {
15450                                 if err == io.EOF {
15451                                         chk(io.EOF)
15452                                 }
15453                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15454                         }
15455                 }
15456                 for local242 := range (*(*(struct {
15457                         Param0 Content
15458
15459                         Name   string
15460                         Groups []Group
15461
15462                         P1Type   Param1Type
15463                         P2Type   Param2Type
15464                         DrawType DrawType
15465
15466                         Mesh  string
15467                         Scale float32
15468                         //mt:const uint8(6)
15469                         Tiles        [6]TileDef
15470                         OverlayTiles [6]TileDef
15471                         //mt:const uint8(6)
15472                         SpecialTiles [6]TileDef
15473
15474                         Color   color.NRGBA
15475                         Palette Texture
15476
15477                         Waving       WaveType
15478                         ConnectSides uint8
15479                         ConnectTo    []Content
15480                         InsideTint   color.NRGBA
15481                         Level        uint8 // Must be < 128.
15482
15483                         Translucent bool // Sunlight is scattered and becomes normal light.
15484                         Transparent bool // Sunlight isn't scattered.
15485                         LightSrc    uint8
15486
15487                         GndContent   bool
15488                         Collides     bool
15489                         Pointable    bool
15490                         Diggable     bool
15491                         Climbable    bool
15492                         Replaceable  bool
15493                         OnRightClick bool
15494
15495                         DmgPerSec int32
15496
15497                         LiquidType   LiquidType
15498                         FlowingAlt   string
15499                         SrcAlt       string
15500                         Viscosity    uint8 // 0-7
15501                         LiqRenewable bool
15502                         FlowRange    uint8
15503                         DrownDmg     uint8
15504                         Floodable    bool
15505
15506                         DrawBox, ColBox, SelBox NodeBox
15507
15508                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15509
15510                         LegacyFaceDir bool
15511                         LegacyMounted bool
15512
15513                         DigPredict string
15514
15515                         MaxLvl uint8
15516
15517                         AlphaUse
15518
15519                         MoveResistance uint8
15520
15521                         LiquidMovePhysics bool
15522                 }))(obj)).OverlayTiles {
15523                         if err := pcall(func() {
15524                                 (((*(*(struct {
15525                                         Param0 Content
15526
15527                                         Name   string
15528                                         Groups []Group
15529
15530                                         P1Type   Param1Type
15531                                         P2Type   Param2Type
15532                                         DrawType DrawType
15533
15534                                         Mesh  string
15535                                         Scale float32
15536                                         //mt:const uint8(6)
15537                                         Tiles        [6]TileDef
15538                                         OverlayTiles [6]TileDef
15539                                         //mt:const uint8(6)
15540                                         SpecialTiles [6]TileDef
15541
15542                                         Color   color.NRGBA
15543                                         Palette Texture
15544
15545                                         Waving       WaveType
15546                                         ConnectSides uint8
15547                                         ConnectTo    []Content
15548                                         InsideTint   color.NRGBA
15549                                         Level        uint8 // Must be < 128.
15550
15551                                         Translucent bool // Sunlight is scattered and becomes normal light.
15552                                         Transparent bool // Sunlight isn't scattered.
15553                                         LightSrc    uint8
15554
15555                                         GndContent   bool
15556                                         Collides     bool
15557                                         Pointable    bool
15558                                         Diggable     bool
15559                                         Climbable    bool
15560                                         Replaceable  bool
15561                                         OnRightClick bool
15562
15563                                         DmgPerSec int32
15564
15565                                         LiquidType   LiquidType
15566                                         FlowingAlt   string
15567                                         SrcAlt       string
15568                                         Viscosity    uint8 // 0-7
15569                                         LiqRenewable bool
15570                                         FlowRange    uint8
15571                                         DrownDmg     uint8
15572                                         Floodable    bool
15573
15574                                         DrawBox, ColBox, SelBox NodeBox
15575
15576                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15577
15578                                         LegacyFaceDir bool
15579                                         LegacyMounted bool
15580
15581                                         DigPredict string
15582
15583                                         MaxLvl uint8
15584
15585                                         AlphaUse
15586
15587                                         MoveResistance uint8
15588
15589                                         LiquidMovePhysics bool
15590                                 }))(obj)).OverlayTiles)[local242]).Serialize(w)
15591                         }); err != nil {
15592                                 if err == io.EOF {
15593                                         chk(io.EOF)
15594                                 }
15595                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15596                         }
15597                 }
15598                 {
15599                         local243 := uint8(6)
15600                         {
15601                                 x := local243
15602                                 write8(w, uint8(x))
15603                         }
15604                 }
15605                 for local244 := range (*(*(struct {
15606                         Param0 Content
15607
15608                         Name   string
15609                         Groups []Group
15610
15611                         P1Type   Param1Type
15612                         P2Type   Param2Type
15613                         DrawType DrawType
15614
15615                         Mesh  string
15616                         Scale float32
15617                         //mt:const uint8(6)
15618                         Tiles        [6]TileDef
15619                         OverlayTiles [6]TileDef
15620                         //mt:const uint8(6)
15621                         SpecialTiles [6]TileDef
15622
15623                         Color   color.NRGBA
15624                         Palette Texture
15625
15626                         Waving       WaveType
15627                         ConnectSides uint8
15628                         ConnectTo    []Content
15629                         InsideTint   color.NRGBA
15630                         Level        uint8 // Must be < 128.
15631
15632                         Translucent bool // Sunlight is scattered and becomes normal light.
15633                         Transparent bool // Sunlight isn't scattered.
15634                         LightSrc    uint8
15635
15636                         GndContent   bool
15637                         Collides     bool
15638                         Pointable    bool
15639                         Diggable     bool
15640                         Climbable    bool
15641                         Replaceable  bool
15642                         OnRightClick bool
15643
15644                         DmgPerSec int32
15645
15646                         LiquidType   LiquidType
15647                         FlowingAlt   string
15648                         SrcAlt       string
15649                         Viscosity    uint8 // 0-7
15650                         LiqRenewable bool
15651                         FlowRange    uint8
15652                         DrownDmg     uint8
15653                         Floodable    bool
15654
15655                         DrawBox, ColBox, SelBox NodeBox
15656
15657                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15658
15659                         LegacyFaceDir bool
15660                         LegacyMounted bool
15661
15662                         DigPredict string
15663
15664                         MaxLvl uint8
15665
15666                         AlphaUse
15667
15668                         MoveResistance uint8
15669
15670                         LiquidMovePhysics bool
15671                 }))(obj)).SpecialTiles {
15672                         if err := pcall(func() {
15673                                 (((*(*(struct {
15674                                         Param0 Content
15675
15676                                         Name   string
15677                                         Groups []Group
15678
15679                                         P1Type   Param1Type
15680                                         P2Type   Param2Type
15681                                         DrawType DrawType
15682
15683                                         Mesh  string
15684                                         Scale float32
15685                                         //mt:const uint8(6)
15686                                         Tiles        [6]TileDef
15687                                         OverlayTiles [6]TileDef
15688                                         //mt:const uint8(6)
15689                                         SpecialTiles [6]TileDef
15690
15691                                         Color   color.NRGBA
15692                                         Palette Texture
15693
15694                                         Waving       WaveType
15695                                         ConnectSides uint8
15696                                         ConnectTo    []Content
15697                                         InsideTint   color.NRGBA
15698                                         Level        uint8 // Must be < 128.
15699
15700                                         Translucent bool // Sunlight is scattered and becomes normal light.
15701                                         Transparent bool // Sunlight isn't scattered.
15702                                         LightSrc    uint8
15703
15704                                         GndContent   bool
15705                                         Collides     bool
15706                                         Pointable    bool
15707                                         Diggable     bool
15708                                         Climbable    bool
15709                                         Replaceable  bool
15710                                         OnRightClick bool
15711
15712                                         DmgPerSec int32
15713
15714                                         LiquidType   LiquidType
15715                                         FlowingAlt   string
15716                                         SrcAlt       string
15717                                         Viscosity    uint8 // 0-7
15718                                         LiqRenewable bool
15719                                         FlowRange    uint8
15720                                         DrownDmg     uint8
15721                                         Floodable    bool
15722
15723                                         DrawBox, ColBox, SelBox NodeBox
15724
15725                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15726
15727                                         LegacyFaceDir bool
15728                                         LegacyMounted bool
15729
15730                                         DigPredict string
15731
15732                                         MaxLvl uint8
15733
15734                                         AlphaUse
15735
15736                                         MoveResistance uint8
15737
15738                                         LiquidMovePhysics bool
15739                                 }))(obj)).SpecialTiles)[local244]).Serialize(w)
15740                         }); err != nil {
15741                                 if err == io.EOF {
15742                                         chk(io.EOF)
15743                                 }
15744                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15745                         }
15746                 }
15747                 {
15748                         x := (*(*(struct {
15749                                 Param0 Content
15750
15751                                 Name   string
15752                                 Groups []Group
15753
15754                                 P1Type   Param1Type
15755                                 P2Type   Param2Type
15756                                 DrawType DrawType
15757
15758                                 Mesh  string
15759                                 Scale float32
15760                                 //mt:const uint8(6)
15761                                 Tiles        [6]TileDef
15762                                 OverlayTiles [6]TileDef
15763                                 //mt:const uint8(6)
15764                                 SpecialTiles [6]TileDef
15765
15766                                 Color   color.NRGBA
15767                                 Palette Texture
15768
15769                                 Waving       WaveType
15770                                 ConnectSides uint8
15771                                 ConnectTo    []Content
15772                                 InsideTint   color.NRGBA
15773                                 Level        uint8 // Must be < 128.
15774
15775                                 Translucent bool // Sunlight is scattered and becomes normal light.
15776                                 Transparent bool // Sunlight isn't scattered.
15777                                 LightSrc    uint8
15778
15779                                 GndContent   bool
15780                                 Collides     bool
15781                                 Pointable    bool
15782                                 Diggable     bool
15783                                 Climbable    bool
15784                                 Replaceable  bool
15785                                 OnRightClick bool
15786
15787                                 DmgPerSec int32
15788
15789                                 LiquidType   LiquidType
15790                                 FlowingAlt   string
15791                                 SrcAlt       string
15792                                 Viscosity    uint8 // 0-7
15793                                 LiqRenewable bool
15794                                 FlowRange    uint8
15795                                 DrownDmg     uint8
15796                                 Floodable    bool
15797
15798                                 DrawBox, ColBox, SelBox NodeBox
15799
15800                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15801
15802                                 LegacyFaceDir bool
15803                                 LegacyMounted bool
15804
15805                                 DigPredict string
15806
15807                                 MaxLvl uint8
15808
15809                                 AlphaUse
15810
15811                                 MoveResistance uint8
15812
15813                                 LiquidMovePhysics bool
15814                         }))(obj)).Color
15815                         w.Write([]byte{x.A, x.R, x.G, x.B})
15816                 }
15817                 if err := pcall(func() {
15818                         ((*(*(struct {
15819                                 Param0 Content
15820
15821                                 Name   string
15822                                 Groups []Group
15823
15824                                 P1Type   Param1Type
15825                                 P2Type   Param2Type
15826                                 DrawType DrawType
15827
15828                                 Mesh  string
15829                                 Scale float32
15830                                 //mt:const uint8(6)
15831                                 Tiles        [6]TileDef
15832                                 OverlayTiles [6]TileDef
15833                                 //mt:const uint8(6)
15834                                 SpecialTiles [6]TileDef
15835
15836                                 Color   color.NRGBA
15837                                 Palette Texture
15838
15839                                 Waving       WaveType
15840                                 ConnectSides uint8
15841                                 ConnectTo    []Content
15842                                 InsideTint   color.NRGBA
15843                                 Level        uint8 // Must be < 128.
15844
15845                                 Translucent bool // Sunlight is scattered and becomes normal light.
15846                                 Transparent bool // Sunlight isn't scattered.
15847                                 LightSrc    uint8
15848
15849                                 GndContent   bool
15850                                 Collides     bool
15851                                 Pointable    bool
15852                                 Diggable     bool
15853                                 Climbable    bool
15854                                 Replaceable  bool
15855                                 OnRightClick bool
15856
15857                                 DmgPerSec int32
15858
15859                                 LiquidType   LiquidType
15860                                 FlowingAlt   string
15861                                 SrcAlt       string
15862                                 Viscosity    uint8 // 0-7
15863                                 LiqRenewable bool
15864                                 FlowRange    uint8
15865                                 DrownDmg     uint8
15866                                 Floodable    bool
15867
15868                                 DrawBox, ColBox, SelBox NodeBox
15869
15870                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15871
15872                                 LegacyFaceDir bool
15873                                 LegacyMounted bool
15874
15875                                 DigPredict string
15876
15877                                 MaxLvl uint8
15878
15879                                 AlphaUse
15880
15881                                 MoveResistance uint8
15882
15883                                 LiquidMovePhysics bool
15884                         }))(obj)).Palette).Serialize(w)
15885                 }); err != nil {
15886                         if err == io.EOF {
15887                                 chk(io.EOF)
15888                         }
15889                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
15890                 }
15891                 if err := pcall(func() {
15892                         ((*(*(struct {
15893                                 Param0 Content
15894
15895                                 Name   string
15896                                 Groups []Group
15897
15898                                 P1Type   Param1Type
15899                                 P2Type   Param2Type
15900                                 DrawType DrawType
15901
15902                                 Mesh  string
15903                                 Scale float32
15904                                 //mt:const uint8(6)
15905                                 Tiles        [6]TileDef
15906                                 OverlayTiles [6]TileDef
15907                                 //mt:const uint8(6)
15908                                 SpecialTiles [6]TileDef
15909
15910                                 Color   color.NRGBA
15911                                 Palette Texture
15912
15913                                 Waving       WaveType
15914                                 ConnectSides uint8
15915                                 ConnectTo    []Content
15916                                 InsideTint   color.NRGBA
15917                                 Level        uint8 // Must be < 128.
15918
15919                                 Translucent bool // Sunlight is scattered and becomes normal light.
15920                                 Transparent bool // Sunlight isn't scattered.
15921                                 LightSrc    uint8
15922
15923                                 GndContent   bool
15924                                 Collides     bool
15925                                 Pointable    bool
15926                                 Diggable     bool
15927                                 Climbable    bool
15928                                 Replaceable  bool
15929                                 OnRightClick bool
15930
15931                                 DmgPerSec int32
15932
15933                                 LiquidType   LiquidType
15934                                 FlowingAlt   string
15935                                 SrcAlt       string
15936                                 Viscosity    uint8 // 0-7
15937                                 LiqRenewable bool
15938                                 FlowRange    uint8
15939                                 DrownDmg     uint8
15940                                 Floodable    bool
15941
15942                                 DrawBox, ColBox, SelBox NodeBox
15943
15944                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15945
15946                                 LegacyFaceDir bool
15947                                 LegacyMounted bool
15948
15949                                 DigPredict string
15950
15951                                 MaxLvl uint8
15952
15953                                 AlphaUse
15954
15955                                 MoveResistance uint8
15956
15957                                 LiquidMovePhysics bool
15958                         }))(obj)).Waving).Serialize(w)
15959                 }); err != nil {
15960                         if err == io.EOF {
15961                                 chk(io.EOF)
15962                         }
15963                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.WaveType", err))
15964                 }
15965                 {
15966                         x := (*(*(struct {
15967                                 Param0 Content
15968
15969                                 Name   string
15970                                 Groups []Group
15971
15972                                 P1Type   Param1Type
15973                                 P2Type   Param2Type
15974                                 DrawType DrawType
15975
15976                                 Mesh  string
15977                                 Scale float32
15978                                 //mt:const uint8(6)
15979                                 Tiles        [6]TileDef
15980                                 OverlayTiles [6]TileDef
15981                                 //mt:const uint8(6)
15982                                 SpecialTiles [6]TileDef
15983
15984                                 Color   color.NRGBA
15985                                 Palette Texture
15986
15987                                 Waving       WaveType
15988                                 ConnectSides uint8
15989                                 ConnectTo    []Content
15990                                 InsideTint   color.NRGBA
15991                                 Level        uint8 // Must be < 128.
15992
15993                                 Translucent bool // Sunlight is scattered and becomes normal light.
15994                                 Transparent bool // Sunlight isn't scattered.
15995                                 LightSrc    uint8
15996
15997                                 GndContent   bool
15998                                 Collides     bool
15999                                 Pointable    bool
16000                                 Diggable     bool
16001                                 Climbable    bool
16002                                 Replaceable  bool
16003                                 OnRightClick bool
16004
16005                                 DmgPerSec int32
16006
16007                                 LiquidType   LiquidType
16008                                 FlowingAlt   string
16009                                 SrcAlt       string
16010                                 Viscosity    uint8 // 0-7
16011                                 LiqRenewable bool
16012                                 FlowRange    uint8
16013                                 DrownDmg     uint8
16014                                 Floodable    bool
16015
16016                                 DrawBox, ColBox, SelBox NodeBox
16017
16018                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16019
16020                                 LegacyFaceDir bool
16021                                 LegacyMounted bool
16022
16023                                 DigPredict string
16024
16025                                 MaxLvl uint8
16026
16027                                 AlphaUse
16028
16029                                 MoveResistance uint8
16030
16031                                 LiquidMovePhysics bool
16032                         }))(obj)).ConnectSides
16033                         write8(w, uint8(x))
16034                 }
16035                 if len(((*(*(struct {
16036                         Param0 Content
16037
16038                         Name   string
16039                         Groups []Group
16040
16041                         P1Type   Param1Type
16042                         P2Type   Param2Type
16043                         DrawType DrawType
16044
16045                         Mesh  string
16046                         Scale float32
16047                         //mt:const uint8(6)
16048                         Tiles        [6]TileDef
16049                         OverlayTiles [6]TileDef
16050                         //mt:const uint8(6)
16051                         SpecialTiles [6]TileDef
16052
16053                         Color   color.NRGBA
16054                         Palette Texture
16055
16056                         Waving       WaveType
16057                         ConnectSides uint8
16058                         ConnectTo    []Content
16059                         InsideTint   color.NRGBA
16060                         Level        uint8 // Must be < 128.
16061
16062                         Translucent bool // Sunlight is scattered and becomes normal light.
16063                         Transparent bool // Sunlight isn't scattered.
16064                         LightSrc    uint8
16065
16066                         GndContent   bool
16067                         Collides     bool
16068                         Pointable    bool
16069                         Diggable     bool
16070                         Climbable    bool
16071                         Replaceable  bool
16072                         OnRightClick bool
16073
16074                         DmgPerSec int32
16075
16076                         LiquidType   LiquidType
16077                         FlowingAlt   string
16078                         SrcAlt       string
16079                         Viscosity    uint8 // 0-7
16080                         LiqRenewable bool
16081                         FlowRange    uint8
16082                         DrownDmg     uint8
16083                         Floodable    bool
16084
16085                         DrawBox, ColBox, SelBox NodeBox
16086
16087                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16088
16089                         LegacyFaceDir bool
16090                         LegacyMounted bool
16091
16092                         DigPredict string
16093
16094                         MaxLvl uint8
16095
16096                         AlphaUse
16097
16098                         MoveResistance uint8
16099
16100                         LiquidMovePhysics bool
16101                 }))(obj)).ConnectTo)) > math.MaxUint16 {
16102                         chk(ErrTooLong)
16103                 }
16104                 {
16105                         x := uint16(len(((*(*(struct {
16106                                 Param0 Content
16107
16108                                 Name   string
16109                                 Groups []Group
16110
16111                                 P1Type   Param1Type
16112                                 P2Type   Param2Type
16113                                 DrawType DrawType
16114
16115                                 Mesh  string
16116                                 Scale float32
16117                                 //mt:const uint8(6)
16118                                 Tiles        [6]TileDef
16119                                 OverlayTiles [6]TileDef
16120                                 //mt:const uint8(6)
16121                                 SpecialTiles [6]TileDef
16122
16123                                 Color   color.NRGBA
16124                                 Palette Texture
16125
16126                                 Waving       WaveType
16127                                 ConnectSides uint8
16128                                 ConnectTo    []Content
16129                                 InsideTint   color.NRGBA
16130                                 Level        uint8 // Must be < 128.
16131
16132                                 Translucent bool // Sunlight is scattered and becomes normal light.
16133                                 Transparent bool // Sunlight isn't scattered.
16134                                 LightSrc    uint8
16135
16136                                 GndContent   bool
16137                                 Collides     bool
16138                                 Pointable    bool
16139                                 Diggable     bool
16140                                 Climbable    bool
16141                                 Replaceable  bool
16142                                 OnRightClick bool
16143
16144                                 DmgPerSec int32
16145
16146                                 LiquidType   LiquidType
16147                                 FlowingAlt   string
16148                                 SrcAlt       string
16149                                 Viscosity    uint8 // 0-7
16150                                 LiqRenewable bool
16151                                 FlowRange    uint8
16152                                 DrownDmg     uint8
16153                                 Floodable    bool
16154
16155                                 DrawBox, ColBox, SelBox NodeBox
16156
16157                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16158
16159                                 LegacyFaceDir bool
16160                                 LegacyMounted bool
16161
16162                                 DigPredict string
16163
16164                                 MaxLvl uint8
16165
16166                                 AlphaUse
16167
16168                                 MoveResistance uint8
16169
16170                                 LiquidMovePhysics bool
16171                         }))(obj)).ConnectTo)))
16172                         write16(w, uint16(x))
16173                 }
16174                 for local245 := range (*(*(struct {
16175                         Param0 Content
16176
16177                         Name   string
16178                         Groups []Group
16179
16180                         P1Type   Param1Type
16181                         P2Type   Param2Type
16182                         DrawType DrawType
16183
16184                         Mesh  string
16185                         Scale float32
16186                         //mt:const uint8(6)
16187                         Tiles        [6]TileDef
16188                         OverlayTiles [6]TileDef
16189                         //mt:const uint8(6)
16190                         SpecialTiles [6]TileDef
16191
16192                         Color   color.NRGBA
16193                         Palette Texture
16194
16195                         Waving       WaveType
16196                         ConnectSides uint8
16197                         ConnectTo    []Content
16198                         InsideTint   color.NRGBA
16199                         Level        uint8 // Must be < 128.
16200
16201                         Translucent bool // Sunlight is scattered and becomes normal light.
16202                         Transparent bool // Sunlight isn't scattered.
16203                         LightSrc    uint8
16204
16205                         GndContent   bool
16206                         Collides     bool
16207                         Pointable    bool
16208                         Diggable     bool
16209                         Climbable    bool
16210                         Replaceable  bool
16211                         OnRightClick bool
16212
16213                         DmgPerSec int32
16214
16215                         LiquidType   LiquidType
16216                         FlowingAlt   string
16217                         SrcAlt       string
16218                         Viscosity    uint8 // 0-7
16219                         LiqRenewable bool
16220                         FlowRange    uint8
16221                         DrownDmg     uint8
16222                         Floodable    bool
16223
16224                         DrawBox, ColBox, SelBox NodeBox
16225
16226                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16227
16228                         LegacyFaceDir bool
16229                         LegacyMounted bool
16230
16231                         DigPredict string
16232
16233                         MaxLvl uint8
16234
16235                         AlphaUse
16236
16237                         MoveResistance uint8
16238
16239                         LiquidMovePhysics bool
16240                 }))(obj)).ConnectTo {
16241                         if err := pcall(func() {
16242                                 (((*(*(struct {
16243                                         Param0 Content
16244
16245                                         Name   string
16246                                         Groups []Group
16247
16248                                         P1Type   Param1Type
16249                                         P2Type   Param2Type
16250                                         DrawType DrawType
16251
16252                                         Mesh  string
16253                                         Scale float32
16254                                         //mt:const uint8(6)
16255                                         Tiles        [6]TileDef
16256                                         OverlayTiles [6]TileDef
16257                                         //mt:const uint8(6)
16258                                         SpecialTiles [6]TileDef
16259
16260                                         Color   color.NRGBA
16261                                         Palette Texture
16262
16263                                         Waving       WaveType
16264                                         ConnectSides uint8
16265                                         ConnectTo    []Content
16266                                         InsideTint   color.NRGBA
16267                                         Level        uint8 // Must be < 128.
16268
16269                                         Translucent bool // Sunlight is scattered and becomes normal light.
16270                                         Transparent bool // Sunlight isn't scattered.
16271                                         LightSrc    uint8
16272
16273                                         GndContent   bool
16274                                         Collides     bool
16275                                         Pointable    bool
16276                                         Diggable     bool
16277                                         Climbable    bool
16278                                         Replaceable  bool
16279                                         OnRightClick bool
16280
16281                                         DmgPerSec int32
16282
16283                                         LiquidType   LiquidType
16284                                         FlowingAlt   string
16285                                         SrcAlt       string
16286                                         Viscosity    uint8 // 0-7
16287                                         LiqRenewable bool
16288                                         FlowRange    uint8
16289                                         DrownDmg     uint8
16290                                         Floodable    bool
16291
16292                                         DrawBox, ColBox, SelBox NodeBox
16293
16294                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16295
16296                                         LegacyFaceDir bool
16297                                         LegacyMounted bool
16298
16299                                         DigPredict string
16300
16301                                         MaxLvl uint8
16302
16303                                         AlphaUse
16304
16305                                         MoveResistance uint8
16306
16307                                         LiquidMovePhysics bool
16308                                 }))(obj)).ConnectTo)[local245]).Serialize(w)
16309                         }); err != nil {
16310                                 if err == io.EOF {
16311                                         chk(io.EOF)
16312                                 }
16313                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
16314                         }
16315                 }
16316                 {
16317                         x := (*(*(struct {
16318                                 Param0 Content
16319
16320                                 Name   string
16321                                 Groups []Group
16322
16323                                 P1Type   Param1Type
16324                                 P2Type   Param2Type
16325                                 DrawType DrawType
16326
16327                                 Mesh  string
16328                                 Scale float32
16329                                 //mt:const uint8(6)
16330                                 Tiles        [6]TileDef
16331                                 OverlayTiles [6]TileDef
16332                                 //mt:const uint8(6)
16333                                 SpecialTiles [6]TileDef
16334
16335                                 Color   color.NRGBA
16336                                 Palette Texture
16337
16338                                 Waving       WaveType
16339                                 ConnectSides uint8
16340                                 ConnectTo    []Content
16341                                 InsideTint   color.NRGBA
16342                                 Level        uint8 // Must be < 128.
16343
16344                                 Translucent bool // Sunlight is scattered and becomes normal light.
16345                                 Transparent bool // Sunlight isn't scattered.
16346                                 LightSrc    uint8
16347
16348                                 GndContent   bool
16349                                 Collides     bool
16350                                 Pointable    bool
16351                                 Diggable     bool
16352                                 Climbable    bool
16353                                 Replaceable  bool
16354                                 OnRightClick bool
16355
16356                                 DmgPerSec int32
16357
16358                                 LiquidType   LiquidType
16359                                 FlowingAlt   string
16360                                 SrcAlt       string
16361                                 Viscosity    uint8 // 0-7
16362                                 LiqRenewable bool
16363                                 FlowRange    uint8
16364                                 DrownDmg     uint8
16365                                 Floodable    bool
16366
16367                                 DrawBox, ColBox, SelBox NodeBox
16368
16369                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16370
16371                                 LegacyFaceDir bool
16372                                 LegacyMounted bool
16373
16374                                 DigPredict string
16375
16376                                 MaxLvl uint8
16377
16378                                 AlphaUse
16379
16380                                 MoveResistance uint8
16381
16382                                 LiquidMovePhysics bool
16383                         }))(obj)).InsideTint
16384                         w.Write([]byte{x.A, x.R, x.G, x.B})
16385                 }
16386                 {
16387                         x := (*(*(struct {
16388                                 Param0 Content
16389
16390                                 Name   string
16391                                 Groups []Group
16392
16393                                 P1Type   Param1Type
16394                                 P2Type   Param2Type
16395                                 DrawType DrawType
16396
16397                                 Mesh  string
16398                                 Scale float32
16399                                 //mt:const uint8(6)
16400                                 Tiles        [6]TileDef
16401                                 OverlayTiles [6]TileDef
16402                                 //mt:const uint8(6)
16403                                 SpecialTiles [6]TileDef
16404
16405                                 Color   color.NRGBA
16406                                 Palette Texture
16407
16408                                 Waving       WaveType
16409                                 ConnectSides uint8
16410                                 ConnectTo    []Content
16411                                 InsideTint   color.NRGBA
16412                                 Level        uint8 // Must be < 128.
16413
16414                                 Translucent bool // Sunlight is scattered and becomes normal light.
16415                                 Transparent bool // Sunlight isn't scattered.
16416                                 LightSrc    uint8
16417
16418                                 GndContent   bool
16419                                 Collides     bool
16420                                 Pointable    bool
16421                                 Diggable     bool
16422                                 Climbable    bool
16423                                 Replaceable  bool
16424                                 OnRightClick bool
16425
16426                                 DmgPerSec int32
16427
16428                                 LiquidType   LiquidType
16429                                 FlowingAlt   string
16430                                 SrcAlt       string
16431                                 Viscosity    uint8 // 0-7
16432                                 LiqRenewable bool
16433                                 FlowRange    uint8
16434                                 DrownDmg     uint8
16435                                 Floodable    bool
16436
16437                                 DrawBox, ColBox, SelBox NodeBox
16438
16439                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16440
16441                                 LegacyFaceDir bool
16442                                 LegacyMounted bool
16443
16444                                 DigPredict string
16445
16446                                 MaxLvl uint8
16447
16448                                 AlphaUse
16449
16450                                 MoveResistance uint8
16451
16452                                 LiquidMovePhysics bool
16453                         }))(obj)).Level
16454                         write8(w, uint8(x))
16455                 }
16456                 {
16457                         x := (*(*(struct {
16458                                 Param0 Content
16459
16460                                 Name   string
16461                                 Groups []Group
16462
16463                                 P1Type   Param1Type
16464                                 P2Type   Param2Type
16465                                 DrawType DrawType
16466
16467                                 Mesh  string
16468                                 Scale float32
16469                                 //mt:const uint8(6)
16470                                 Tiles        [6]TileDef
16471                                 OverlayTiles [6]TileDef
16472                                 //mt:const uint8(6)
16473                                 SpecialTiles [6]TileDef
16474
16475                                 Color   color.NRGBA
16476                                 Palette Texture
16477
16478                                 Waving       WaveType
16479                                 ConnectSides uint8
16480                                 ConnectTo    []Content
16481                                 InsideTint   color.NRGBA
16482                                 Level        uint8 // Must be < 128.
16483
16484                                 Translucent bool // Sunlight is scattered and becomes normal light.
16485                                 Transparent bool // Sunlight isn't scattered.
16486                                 LightSrc    uint8
16487
16488                                 GndContent   bool
16489                                 Collides     bool
16490                                 Pointable    bool
16491                                 Diggable     bool
16492                                 Climbable    bool
16493                                 Replaceable  bool
16494                                 OnRightClick bool
16495
16496                                 DmgPerSec int32
16497
16498                                 LiquidType   LiquidType
16499                                 FlowingAlt   string
16500                                 SrcAlt       string
16501                                 Viscosity    uint8 // 0-7
16502                                 LiqRenewable bool
16503                                 FlowRange    uint8
16504                                 DrownDmg     uint8
16505                                 Floodable    bool
16506
16507                                 DrawBox, ColBox, SelBox NodeBox
16508
16509                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16510
16511                                 LegacyFaceDir bool
16512                                 LegacyMounted bool
16513
16514                                 DigPredict string
16515
16516                                 MaxLvl uint8
16517
16518                                 AlphaUse
16519
16520                                 MoveResistance uint8
16521
16522                                 LiquidMovePhysics bool
16523                         }))(obj)).Translucent
16524                         if x {
16525                                 write8(w, 1)
16526                         } else {
16527                                 write8(w, 0)
16528                         }
16529                 }
16530                 {
16531                         x := (*(*(struct {
16532                                 Param0 Content
16533
16534                                 Name   string
16535                                 Groups []Group
16536
16537                                 P1Type   Param1Type
16538                                 P2Type   Param2Type
16539                                 DrawType DrawType
16540
16541                                 Mesh  string
16542                                 Scale float32
16543                                 //mt:const uint8(6)
16544                                 Tiles        [6]TileDef
16545                                 OverlayTiles [6]TileDef
16546                                 //mt:const uint8(6)
16547                                 SpecialTiles [6]TileDef
16548
16549                                 Color   color.NRGBA
16550                                 Palette Texture
16551
16552                                 Waving       WaveType
16553                                 ConnectSides uint8
16554                                 ConnectTo    []Content
16555                                 InsideTint   color.NRGBA
16556                                 Level        uint8 // Must be < 128.
16557
16558                                 Translucent bool // Sunlight is scattered and becomes normal light.
16559                                 Transparent bool // Sunlight isn't scattered.
16560                                 LightSrc    uint8
16561
16562                                 GndContent   bool
16563                                 Collides     bool
16564                                 Pointable    bool
16565                                 Diggable     bool
16566                                 Climbable    bool
16567                                 Replaceable  bool
16568                                 OnRightClick bool
16569
16570                                 DmgPerSec int32
16571
16572                                 LiquidType   LiquidType
16573                                 FlowingAlt   string
16574                                 SrcAlt       string
16575                                 Viscosity    uint8 // 0-7
16576                                 LiqRenewable bool
16577                                 FlowRange    uint8
16578                                 DrownDmg     uint8
16579                                 Floodable    bool
16580
16581                                 DrawBox, ColBox, SelBox NodeBox
16582
16583                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16584
16585                                 LegacyFaceDir bool
16586                                 LegacyMounted bool
16587
16588                                 DigPredict string
16589
16590                                 MaxLvl uint8
16591
16592                                 AlphaUse
16593
16594                                 MoveResistance uint8
16595
16596                                 LiquidMovePhysics bool
16597                         }))(obj)).Transparent
16598                         if x {
16599                                 write8(w, 1)
16600                         } else {
16601                                 write8(w, 0)
16602                         }
16603                 }
16604                 {
16605                         x := (*(*(struct {
16606                                 Param0 Content
16607
16608                                 Name   string
16609                                 Groups []Group
16610
16611                                 P1Type   Param1Type
16612                                 P2Type   Param2Type
16613                                 DrawType DrawType
16614
16615                                 Mesh  string
16616                                 Scale float32
16617                                 //mt:const uint8(6)
16618                                 Tiles        [6]TileDef
16619                                 OverlayTiles [6]TileDef
16620                                 //mt:const uint8(6)
16621                                 SpecialTiles [6]TileDef
16622
16623                                 Color   color.NRGBA
16624                                 Palette Texture
16625
16626                                 Waving       WaveType
16627                                 ConnectSides uint8
16628                                 ConnectTo    []Content
16629                                 InsideTint   color.NRGBA
16630                                 Level        uint8 // Must be < 128.
16631
16632                                 Translucent bool // Sunlight is scattered and becomes normal light.
16633                                 Transparent bool // Sunlight isn't scattered.
16634                                 LightSrc    uint8
16635
16636                                 GndContent   bool
16637                                 Collides     bool
16638                                 Pointable    bool
16639                                 Diggable     bool
16640                                 Climbable    bool
16641                                 Replaceable  bool
16642                                 OnRightClick bool
16643
16644                                 DmgPerSec int32
16645
16646                                 LiquidType   LiquidType
16647                                 FlowingAlt   string
16648                                 SrcAlt       string
16649                                 Viscosity    uint8 // 0-7
16650                                 LiqRenewable bool
16651                                 FlowRange    uint8
16652                                 DrownDmg     uint8
16653                                 Floodable    bool
16654
16655                                 DrawBox, ColBox, SelBox NodeBox
16656
16657                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16658
16659                                 LegacyFaceDir bool
16660                                 LegacyMounted bool
16661
16662                                 DigPredict string
16663
16664                                 MaxLvl uint8
16665
16666                                 AlphaUse
16667
16668                                 MoveResistance uint8
16669
16670                                 LiquidMovePhysics bool
16671                         }))(obj)).LightSrc
16672                         write8(w, uint8(x))
16673                 }
16674                 {
16675                         x := (*(*(struct {
16676                                 Param0 Content
16677
16678                                 Name   string
16679                                 Groups []Group
16680
16681                                 P1Type   Param1Type
16682                                 P2Type   Param2Type
16683                                 DrawType DrawType
16684
16685                                 Mesh  string
16686                                 Scale float32
16687                                 //mt:const uint8(6)
16688                                 Tiles        [6]TileDef
16689                                 OverlayTiles [6]TileDef
16690                                 //mt:const uint8(6)
16691                                 SpecialTiles [6]TileDef
16692
16693                                 Color   color.NRGBA
16694                                 Palette Texture
16695
16696                                 Waving       WaveType
16697                                 ConnectSides uint8
16698                                 ConnectTo    []Content
16699                                 InsideTint   color.NRGBA
16700                                 Level        uint8 // Must be < 128.
16701
16702                                 Translucent bool // Sunlight is scattered and becomes normal light.
16703                                 Transparent bool // Sunlight isn't scattered.
16704                                 LightSrc    uint8
16705
16706                                 GndContent   bool
16707                                 Collides     bool
16708                                 Pointable    bool
16709                                 Diggable     bool
16710                                 Climbable    bool
16711                                 Replaceable  bool
16712                                 OnRightClick bool
16713
16714                                 DmgPerSec int32
16715
16716                                 LiquidType   LiquidType
16717                                 FlowingAlt   string
16718                                 SrcAlt       string
16719                                 Viscosity    uint8 // 0-7
16720                                 LiqRenewable bool
16721                                 FlowRange    uint8
16722                                 DrownDmg     uint8
16723                                 Floodable    bool
16724
16725                                 DrawBox, ColBox, SelBox NodeBox
16726
16727                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16728
16729                                 LegacyFaceDir bool
16730                                 LegacyMounted bool
16731
16732                                 DigPredict string
16733
16734                                 MaxLvl uint8
16735
16736                                 AlphaUse
16737
16738                                 MoveResistance uint8
16739
16740                                 LiquidMovePhysics bool
16741                         }))(obj)).GndContent
16742                         if x {
16743                                 write8(w, 1)
16744                         } else {
16745                                 write8(w, 0)
16746                         }
16747                 }
16748                 {
16749                         x := (*(*(struct {
16750                                 Param0 Content
16751
16752                                 Name   string
16753                                 Groups []Group
16754
16755                                 P1Type   Param1Type
16756                                 P2Type   Param2Type
16757                                 DrawType DrawType
16758
16759                                 Mesh  string
16760                                 Scale float32
16761                                 //mt:const uint8(6)
16762                                 Tiles        [6]TileDef
16763                                 OverlayTiles [6]TileDef
16764                                 //mt:const uint8(6)
16765                                 SpecialTiles [6]TileDef
16766
16767                                 Color   color.NRGBA
16768                                 Palette Texture
16769
16770                                 Waving       WaveType
16771                                 ConnectSides uint8
16772                                 ConnectTo    []Content
16773                                 InsideTint   color.NRGBA
16774                                 Level        uint8 // Must be < 128.
16775
16776                                 Translucent bool // Sunlight is scattered and becomes normal light.
16777                                 Transparent bool // Sunlight isn't scattered.
16778                                 LightSrc    uint8
16779
16780                                 GndContent   bool
16781                                 Collides     bool
16782                                 Pointable    bool
16783                                 Diggable     bool
16784                                 Climbable    bool
16785                                 Replaceable  bool
16786                                 OnRightClick bool
16787
16788                                 DmgPerSec int32
16789
16790                                 LiquidType   LiquidType
16791                                 FlowingAlt   string
16792                                 SrcAlt       string
16793                                 Viscosity    uint8 // 0-7
16794                                 LiqRenewable bool
16795                                 FlowRange    uint8
16796                                 DrownDmg     uint8
16797                                 Floodable    bool
16798
16799                                 DrawBox, ColBox, SelBox NodeBox
16800
16801                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16802
16803                                 LegacyFaceDir bool
16804                                 LegacyMounted bool
16805
16806                                 DigPredict string
16807
16808                                 MaxLvl uint8
16809
16810                                 AlphaUse
16811
16812                                 MoveResistance uint8
16813
16814                                 LiquidMovePhysics bool
16815                         }))(obj)).Collides
16816                         if x {
16817                                 write8(w, 1)
16818                         } else {
16819                                 write8(w, 0)
16820                         }
16821                 }
16822                 {
16823                         x := (*(*(struct {
16824                                 Param0 Content
16825
16826                                 Name   string
16827                                 Groups []Group
16828
16829                                 P1Type   Param1Type
16830                                 P2Type   Param2Type
16831                                 DrawType DrawType
16832
16833                                 Mesh  string
16834                                 Scale float32
16835                                 //mt:const uint8(6)
16836                                 Tiles        [6]TileDef
16837                                 OverlayTiles [6]TileDef
16838                                 //mt:const uint8(6)
16839                                 SpecialTiles [6]TileDef
16840
16841                                 Color   color.NRGBA
16842                                 Palette Texture
16843
16844                                 Waving       WaveType
16845                                 ConnectSides uint8
16846                                 ConnectTo    []Content
16847                                 InsideTint   color.NRGBA
16848                                 Level        uint8 // Must be < 128.
16849
16850                                 Translucent bool // Sunlight is scattered and becomes normal light.
16851                                 Transparent bool // Sunlight isn't scattered.
16852                                 LightSrc    uint8
16853
16854                                 GndContent   bool
16855                                 Collides     bool
16856                                 Pointable    bool
16857                                 Diggable     bool
16858                                 Climbable    bool
16859                                 Replaceable  bool
16860                                 OnRightClick bool
16861
16862                                 DmgPerSec int32
16863
16864                                 LiquidType   LiquidType
16865                                 FlowingAlt   string
16866                                 SrcAlt       string
16867                                 Viscosity    uint8 // 0-7
16868                                 LiqRenewable bool
16869                                 FlowRange    uint8
16870                                 DrownDmg     uint8
16871                                 Floodable    bool
16872
16873                                 DrawBox, ColBox, SelBox NodeBox
16874
16875                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16876
16877                                 LegacyFaceDir bool
16878                                 LegacyMounted bool
16879
16880                                 DigPredict string
16881
16882                                 MaxLvl uint8
16883
16884                                 AlphaUse
16885
16886                                 MoveResistance uint8
16887
16888                                 LiquidMovePhysics bool
16889                         }))(obj)).Pointable
16890                         if x {
16891                                 write8(w, 1)
16892                         } else {
16893                                 write8(w, 0)
16894                         }
16895                 }
16896                 {
16897                         x := (*(*(struct {
16898                                 Param0 Content
16899
16900                                 Name   string
16901                                 Groups []Group
16902
16903                                 P1Type   Param1Type
16904                                 P2Type   Param2Type
16905                                 DrawType DrawType
16906
16907                                 Mesh  string
16908                                 Scale float32
16909                                 //mt:const uint8(6)
16910                                 Tiles        [6]TileDef
16911                                 OverlayTiles [6]TileDef
16912                                 //mt:const uint8(6)
16913                                 SpecialTiles [6]TileDef
16914
16915                                 Color   color.NRGBA
16916                                 Palette Texture
16917
16918                                 Waving       WaveType
16919                                 ConnectSides uint8
16920                                 ConnectTo    []Content
16921                                 InsideTint   color.NRGBA
16922                                 Level        uint8 // Must be < 128.
16923
16924                                 Translucent bool // Sunlight is scattered and becomes normal light.
16925                                 Transparent bool // Sunlight isn't scattered.
16926                                 LightSrc    uint8
16927
16928                                 GndContent   bool
16929                                 Collides     bool
16930                                 Pointable    bool
16931                                 Diggable     bool
16932                                 Climbable    bool
16933                                 Replaceable  bool
16934                                 OnRightClick bool
16935
16936                                 DmgPerSec int32
16937
16938                                 LiquidType   LiquidType
16939                                 FlowingAlt   string
16940                                 SrcAlt       string
16941                                 Viscosity    uint8 // 0-7
16942                                 LiqRenewable bool
16943                                 FlowRange    uint8
16944                                 DrownDmg     uint8
16945                                 Floodable    bool
16946
16947                                 DrawBox, ColBox, SelBox NodeBox
16948
16949                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16950
16951                                 LegacyFaceDir bool
16952                                 LegacyMounted bool
16953
16954                                 DigPredict string
16955
16956                                 MaxLvl uint8
16957
16958                                 AlphaUse
16959
16960                                 MoveResistance uint8
16961
16962                                 LiquidMovePhysics bool
16963                         }))(obj)).Diggable
16964                         if x {
16965                                 write8(w, 1)
16966                         } else {
16967                                 write8(w, 0)
16968                         }
16969                 }
16970                 {
16971                         x := (*(*(struct {
16972                                 Param0 Content
16973
16974                                 Name   string
16975                                 Groups []Group
16976
16977                                 P1Type   Param1Type
16978                                 P2Type   Param2Type
16979                                 DrawType DrawType
16980
16981                                 Mesh  string
16982                                 Scale float32
16983                                 //mt:const uint8(6)
16984                                 Tiles        [6]TileDef
16985                                 OverlayTiles [6]TileDef
16986                                 //mt:const uint8(6)
16987                                 SpecialTiles [6]TileDef
16988
16989                                 Color   color.NRGBA
16990                                 Palette Texture
16991
16992                                 Waving       WaveType
16993                                 ConnectSides uint8
16994                                 ConnectTo    []Content
16995                                 InsideTint   color.NRGBA
16996                                 Level        uint8 // Must be < 128.
16997
16998                                 Translucent bool // Sunlight is scattered and becomes normal light.
16999                                 Transparent bool // Sunlight isn't scattered.
17000                                 LightSrc    uint8
17001
17002                                 GndContent   bool
17003                                 Collides     bool
17004                                 Pointable    bool
17005                                 Diggable     bool
17006                                 Climbable    bool
17007                                 Replaceable  bool
17008                                 OnRightClick bool
17009
17010                                 DmgPerSec int32
17011
17012                                 LiquidType   LiquidType
17013                                 FlowingAlt   string
17014                                 SrcAlt       string
17015                                 Viscosity    uint8 // 0-7
17016                                 LiqRenewable bool
17017                                 FlowRange    uint8
17018                                 DrownDmg     uint8
17019                                 Floodable    bool
17020
17021                                 DrawBox, ColBox, SelBox NodeBox
17022
17023                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17024
17025                                 LegacyFaceDir bool
17026                                 LegacyMounted bool
17027
17028                                 DigPredict string
17029
17030                                 MaxLvl uint8
17031
17032                                 AlphaUse
17033
17034                                 MoveResistance uint8
17035
17036                                 LiquidMovePhysics bool
17037                         }))(obj)).Climbable
17038                         if x {
17039                                 write8(w, 1)
17040                         } else {
17041                                 write8(w, 0)
17042                         }
17043                 }
17044                 {
17045                         x := (*(*(struct {
17046                                 Param0 Content
17047
17048                                 Name   string
17049                                 Groups []Group
17050
17051                                 P1Type   Param1Type
17052                                 P2Type   Param2Type
17053                                 DrawType DrawType
17054
17055                                 Mesh  string
17056                                 Scale float32
17057                                 //mt:const uint8(6)
17058                                 Tiles        [6]TileDef
17059                                 OverlayTiles [6]TileDef
17060                                 //mt:const uint8(6)
17061                                 SpecialTiles [6]TileDef
17062
17063                                 Color   color.NRGBA
17064                                 Palette Texture
17065
17066                                 Waving       WaveType
17067                                 ConnectSides uint8
17068                                 ConnectTo    []Content
17069                                 InsideTint   color.NRGBA
17070                                 Level        uint8 // Must be < 128.
17071
17072                                 Translucent bool // Sunlight is scattered and becomes normal light.
17073                                 Transparent bool // Sunlight isn't scattered.
17074                                 LightSrc    uint8
17075
17076                                 GndContent   bool
17077                                 Collides     bool
17078                                 Pointable    bool
17079                                 Diggable     bool
17080                                 Climbable    bool
17081                                 Replaceable  bool
17082                                 OnRightClick bool
17083
17084                                 DmgPerSec int32
17085
17086                                 LiquidType   LiquidType
17087                                 FlowingAlt   string
17088                                 SrcAlt       string
17089                                 Viscosity    uint8 // 0-7
17090                                 LiqRenewable bool
17091                                 FlowRange    uint8
17092                                 DrownDmg     uint8
17093                                 Floodable    bool
17094
17095                                 DrawBox, ColBox, SelBox NodeBox
17096
17097                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17098
17099                                 LegacyFaceDir bool
17100                                 LegacyMounted bool
17101
17102                                 DigPredict string
17103
17104                                 MaxLvl uint8
17105
17106                                 AlphaUse
17107
17108                                 MoveResistance uint8
17109
17110                                 LiquidMovePhysics bool
17111                         }))(obj)).Replaceable
17112                         if x {
17113                                 write8(w, 1)
17114                         } else {
17115                                 write8(w, 0)
17116                         }
17117                 }
17118                 {
17119                         x := (*(*(struct {
17120                                 Param0 Content
17121
17122                                 Name   string
17123                                 Groups []Group
17124
17125                                 P1Type   Param1Type
17126                                 P2Type   Param2Type
17127                                 DrawType DrawType
17128
17129                                 Mesh  string
17130                                 Scale float32
17131                                 //mt:const uint8(6)
17132                                 Tiles        [6]TileDef
17133                                 OverlayTiles [6]TileDef
17134                                 //mt:const uint8(6)
17135                                 SpecialTiles [6]TileDef
17136
17137                                 Color   color.NRGBA
17138                                 Palette Texture
17139
17140                                 Waving       WaveType
17141                                 ConnectSides uint8
17142                                 ConnectTo    []Content
17143                                 InsideTint   color.NRGBA
17144                                 Level        uint8 // Must be < 128.
17145
17146                                 Translucent bool // Sunlight is scattered and becomes normal light.
17147                                 Transparent bool // Sunlight isn't scattered.
17148                                 LightSrc    uint8
17149
17150                                 GndContent   bool
17151                                 Collides     bool
17152                                 Pointable    bool
17153                                 Diggable     bool
17154                                 Climbable    bool
17155                                 Replaceable  bool
17156                                 OnRightClick bool
17157
17158                                 DmgPerSec int32
17159
17160                                 LiquidType   LiquidType
17161                                 FlowingAlt   string
17162                                 SrcAlt       string
17163                                 Viscosity    uint8 // 0-7
17164                                 LiqRenewable bool
17165                                 FlowRange    uint8
17166                                 DrownDmg     uint8
17167                                 Floodable    bool
17168
17169                                 DrawBox, ColBox, SelBox NodeBox
17170
17171                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17172
17173                                 LegacyFaceDir bool
17174                                 LegacyMounted bool
17175
17176                                 DigPredict string
17177
17178                                 MaxLvl uint8
17179
17180                                 AlphaUse
17181
17182                                 MoveResistance uint8
17183
17184                                 LiquidMovePhysics bool
17185                         }))(obj)).OnRightClick
17186                         if x {
17187                                 write8(w, 1)
17188                         } else {
17189                                 write8(w, 0)
17190                         }
17191                 }
17192                 {
17193                         x := (*(*(struct {
17194                                 Param0 Content
17195
17196                                 Name   string
17197                                 Groups []Group
17198
17199                                 P1Type   Param1Type
17200                                 P2Type   Param2Type
17201                                 DrawType DrawType
17202
17203                                 Mesh  string
17204                                 Scale float32
17205                                 //mt:const uint8(6)
17206                                 Tiles        [6]TileDef
17207                                 OverlayTiles [6]TileDef
17208                                 //mt:const uint8(6)
17209                                 SpecialTiles [6]TileDef
17210
17211                                 Color   color.NRGBA
17212                                 Palette Texture
17213
17214                                 Waving       WaveType
17215                                 ConnectSides uint8
17216                                 ConnectTo    []Content
17217                                 InsideTint   color.NRGBA
17218                                 Level        uint8 // Must be < 128.
17219
17220                                 Translucent bool // Sunlight is scattered and becomes normal light.
17221                                 Transparent bool // Sunlight isn't scattered.
17222                                 LightSrc    uint8
17223
17224                                 GndContent   bool
17225                                 Collides     bool
17226                                 Pointable    bool
17227                                 Diggable     bool
17228                                 Climbable    bool
17229                                 Replaceable  bool
17230                                 OnRightClick bool
17231
17232                                 DmgPerSec int32
17233
17234                                 LiquidType   LiquidType
17235                                 FlowingAlt   string
17236                                 SrcAlt       string
17237                                 Viscosity    uint8 // 0-7
17238                                 LiqRenewable bool
17239                                 FlowRange    uint8
17240                                 DrownDmg     uint8
17241                                 Floodable    bool
17242
17243                                 DrawBox, ColBox, SelBox NodeBox
17244
17245                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17246
17247                                 LegacyFaceDir bool
17248                                 LegacyMounted bool
17249
17250                                 DigPredict string
17251
17252                                 MaxLvl uint8
17253
17254                                 AlphaUse
17255
17256                                 MoveResistance uint8
17257
17258                                 LiquidMovePhysics bool
17259                         }))(obj)).DmgPerSec
17260                         write32(w, uint32(x))
17261                 }
17262                 if err := pcall(func() {
17263                         ((*(*(struct {
17264                                 Param0 Content
17265
17266                                 Name   string
17267                                 Groups []Group
17268
17269                                 P1Type   Param1Type
17270                                 P2Type   Param2Type
17271                                 DrawType DrawType
17272
17273                                 Mesh  string
17274                                 Scale float32
17275                                 //mt:const uint8(6)
17276                                 Tiles        [6]TileDef
17277                                 OverlayTiles [6]TileDef
17278                                 //mt:const uint8(6)
17279                                 SpecialTiles [6]TileDef
17280
17281                                 Color   color.NRGBA
17282                                 Palette Texture
17283
17284                                 Waving       WaveType
17285                                 ConnectSides uint8
17286                                 ConnectTo    []Content
17287                                 InsideTint   color.NRGBA
17288                                 Level        uint8 // Must be < 128.
17289
17290                                 Translucent bool // Sunlight is scattered and becomes normal light.
17291                                 Transparent bool // Sunlight isn't scattered.
17292                                 LightSrc    uint8
17293
17294                                 GndContent   bool
17295                                 Collides     bool
17296                                 Pointable    bool
17297                                 Diggable     bool
17298                                 Climbable    bool
17299                                 Replaceable  bool
17300                                 OnRightClick bool
17301
17302                                 DmgPerSec int32
17303
17304                                 LiquidType   LiquidType
17305                                 FlowingAlt   string
17306                                 SrcAlt       string
17307                                 Viscosity    uint8 // 0-7
17308                                 LiqRenewable bool
17309                                 FlowRange    uint8
17310                                 DrownDmg     uint8
17311                                 Floodable    bool
17312
17313                                 DrawBox, ColBox, SelBox NodeBox
17314
17315                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17316
17317                                 LegacyFaceDir bool
17318                                 LegacyMounted bool
17319
17320                                 DigPredict string
17321
17322                                 MaxLvl uint8
17323
17324                                 AlphaUse
17325
17326                                 MoveResistance uint8
17327
17328                                 LiquidMovePhysics bool
17329                         }))(obj)).LiquidType).Serialize(w)
17330                 }); err != nil {
17331                         if err == io.EOF {
17332                                 chk(io.EOF)
17333                         }
17334                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LiquidType", err))
17335                 }
17336                 if len(([]byte((*(*(struct {
17337                         Param0 Content
17338
17339                         Name   string
17340                         Groups []Group
17341
17342                         P1Type   Param1Type
17343                         P2Type   Param2Type
17344                         DrawType DrawType
17345
17346                         Mesh  string
17347                         Scale float32
17348                         //mt:const uint8(6)
17349                         Tiles        [6]TileDef
17350                         OverlayTiles [6]TileDef
17351                         //mt:const uint8(6)
17352                         SpecialTiles [6]TileDef
17353
17354                         Color   color.NRGBA
17355                         Palette Texture
17356
17357                         Waving       WaveType
17358                         ConnectSides uint8
17359                         ConnectTo    []Content
17360                         InsideTint   color.NRGBA
17361                         Level        uint8 // Must be < 128.
17362
17363                         Translucent bool // Sunlight is scattered and becomes normal light.
17364                         Transparent bool // Sunlight isn't scattered.
17365                         LightSrc    uint8
17366
17367                         GndContent   bool
17368                         Collides     bool
17369                         Pointable    bool
17370                         Diggable     bool
17371                         Climbable    bool
17372                         Replaceable  bool
17373                         OnRightClick bool
17374
17375                         DmgPerSec int32
17376
17377                         LiquidType   LiquidType
17378                         FlowingAlt   string
17379                         SrcAlt       string
17380                         Viscosity    uint8 // 0-7
17381                         LiqRenewable bool
17382                         FlowRange    uint8
17383                         DrownDmg     uint8
17384                         Floodable    bool
17385
17386                         DrawBox, ColBox, SelBox NodeBox
17387
17388                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17389
17390                         LegacyFaceDir bool
17391                         LegacyMounted bool
17392
17393                         DigPredict string
17394
17395                         MaxLvl uint8
17396
17397                         AlphaUse
17398
17399                         MoveResistance uint8
17400
17401                         LiquidMovePhysics bool
17402                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
17403                         chk(ErrTooLong)
17404                 }
17405                 {
17406                         x := uint16(len(([]byte((*(*(struct {
17407                                 Param0 Content
17408
17409                                 Name   string
17410                                 Groups []Group
17411
17412                                 P1Type   Param1Type
17413                                 P2Type   Param2Type
17414                                 DrawType DrawType
17415
17416                                 Mesh  string
17417                                 Scale float32
17418                                 //mt:const uint8(6)
17419                                 Tiles        [6]TileDef
17420                                 OverlayTiles [6]TileDef
17421                                 //mt:const uint8(6)
17422                                 SpecialTiles [6]TileDef
17423
17424                                 Color   color.NRGBA
17425                                 Palette Texture
17426
17427                                 Waving       WaveType
17428                                 ConnectSides uint8
17429                                 ConnectTo    []Content
17430                                 InsideTint   color.NRGBA
17431                                 Level        uint8 // Must be < 128.
17432
17433                                 Translucent bool // Sunlight is scattered and becomes normal light.
17434                                 Transparent bool // Sunlight isn't scattered.
17435                                 LightSrc    uint8
17436
17437                                 GndContent   bool
17438                                 Collides     bool
17439                                 Pointable    bool
17440                                 Diggable     bool
17441                                 Climbable    bool
17442                                 Replaceable  bool
17443                                 OnRightClick bool
17444
17445                                 DmgPerSec int32
17446
17447                                 LiquidType   LiquidType
17448                                 FlowingAlt   string
17449                                 SrcAlt       string
17450                                 Viscosity    uint8 // 0-7
17451                                 LiqRenewable bool
17452                                 FlowRange    uint8
17453                                 DrownDmg     uint8
17454                                 Floodable    bool
17455
17456                                 DrawBox, ColBox, SelBox NodeBox
17457
17458                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17459
17460                                 LegacyFaceDir bool
17461                                 LegacyMounted bool
17462
17463                                 DigPredict string
17464
17465                                 MaxLvl uint8
17466
17467                                 AlphaUse
17468
17469                                 MoveResistance uint8
17470
17471                                 LiquidMovePhysics bool
17472                         }))(obj)).FlowingAlt))))
17473                         write16(w, uint16(x))
17474                 }
17475                 {
17476                         _, err := w.Write(([]byte((*(*(struct {
17477                                 Param0 Content
17478
17479                                 Name   string
17480                                 Groups []Group
17481
17482                                 P1Type   Param1Type
17483                                 P2Type   Param2Type
17484                                 DrawType DrawType
17485
17486                                 Mesh  string
17487                                 Scale float32
17488                                 //mt:const uint8(6)
17489                                 Tiles        [6]TileDef
17490                                 OverlayTiles [6]TileDef
17491                                 //mt:const uint8(6)
17492                                 SpecialTiles [6]TileDef
17493
17494                                 Color   color.NRGBA
17495                                 Palette Texture
17496
17497                                 Waving       WaveType
17498                                 ConnectSides uint8
17499                                 ConnectTo    []Content
17500                                 InsideTint   color.NRGBA
17501                                 Level        uint8 // Must be < 128.
17502
17503                                 Translucent bool // Sunlight is scattered and becomes normal light.
17504                                 Transparent bool // Sunlight isn't scattered.
17505                                 LightSrc    uint8
17506
17507                                 GndContent   bool
17508                                 Collides     bool
17509                                 Pointable    bool
17510                                 Diggable     bool
17511                                 Climbable    bool
17512                                 Replaceable  bool
17513                                 OnRightClick bool
17514
17515                                 DmgPerSec int32
17516
17517                                 LiquidType   LiquidType
17518                                 FlowingAlt   string
17519                                 SrcAlt       string
17520                                 Viscosity    uint8 // 0-7
17521                                 LiqRenewable bool
17522                                 FlowRange    uint8
17523                                 DrownDmg     uint8
17524                                 Floodable    bool
17525
17526                                 DrawBox, ColBox, SelBox NodeBox
17527
17528                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17529
17530                                 LegacyFaceDir bool
17531                                 LegacyMounted bool
17532
17533                                 DigPredict string
17534
17535                                 MaxLvl uint8
17536
17537                                 AlphaUse
17538
17539                                 MoveResistance uint8
17540
17541                                 LiquidMovePhysics bool
17542                         }))(obj)).FlowingAlt))[:])
17543                         chk(err)
17544                 }
17545                 if len(([]byte((*(*(struct {
17546                         Param0 Content
17547
17548                         Name   string
17549                         Groups []Group
17550
17551                         P1Type   Param1Type
17552                         P2Type   Param2Type
17553                         DrawType DrawType
17554
17555                         Mesh  string
17556                         Scale float32
17557                         //mt:const uint8(6)
17558                         Tiles        [6]TileDef
17559                         OverlayTiles [6]TileDef
17560                         //mt:const uint8(6)
17561                         SpecialTiles [6]TileDef
17562
17563                         Color   color.NRGBA
17564                         Palette Texture
17565
17566                         Waving       WaveType
17567                         ConnectSides uint8
17568                         ConnectTo    []Content
17569                         InsideTint   color.NRGBA
17570                         Level        uint8 // Must be < 128.
17571
17572                         Translucent bool // Sunlight is scattered and becomes normal light.
17573                         Transparent bool // Sunlight isn't scattered.
17574                         LightSrc    uint8
17575
17576                         GndContent   bool
17577                         Collides     bool
17578                         Pointable    bool
17579                         Diggable     bool
17580                         Climbable    bool
17581                         Replaceable  bool
17582                         OnRightClick bool
17583
17584                         DmgPerSec int32
17585
17586                         LiquidType   LiquidType
17587                         FlowingAlt   string
17588                         SrcAlt       string
17589                         Viscosity    uint8 // 0-7
17590                         LiqRenewable bool
17591                         FlowRange    uint8
17592                         DrownDmg     uint8
17593                         Floodable    bool
17594
17595                         DrawBox, ColBox, SelBox NodeBox
17596
17597                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17598
17599                         LegacyFaceDir bool
17600                         LegacyMounted bool
17601
17602                         DigPredict string
17603
17604                         MaxLvl uint8
17605
17606                         AlphaUse
17607
17608                         MoveResistance uint8
17609
17610                         LiquidMovePhysics bool
17611                 }))(obj)).SrcAlt))) > math.MaxUint16 {
17612                         chk(ErrTooLong)
17613                 }
17614                 {
17615                         x := uint16(len(([]byte((*(*(struct {
17616                                 Param0 Content
17617
17618                                 Name   string
17619                                 Groups []Group
17620
17621                                 P1Type   Param1Type
17622                                 P2Type   Param2Type
17623                                 DrawType DrawType
17624
17625                                 Mesh  string
17626                                 Scale float32
17627                                 //mt:const uint8(6)
17628                                 Tiles        [6]TileDef
17629                                 OverlayTiles [6]TileDef
17630                                 //mt:const uint8(6)
17631                                 SpecialTiles [6]TileDef
17632
17633                                 Color   color.NRGBA
17634                                 Palette Texture
17635
17636                                 Waving       WaveType
17637                                 ConnectSides uint8
17638                                 ConnectTo    []Content
17639                                 InsideTint   color.NRGBA
17640                                 Level        uint8 // Must be < 128.
17641
17642                                 Translucent bool // Sunlight is scattered and becomes normal light.
17643                                 Transparent bool // Sunlight isn't scattered.
17644                                 LightSrc    uint8
17645
17646                                 GndContent   bool
17647                                 Collides     bool
17648                                 Pointable    bool
17649                                 Diggable     bool
17650                                 Climbable    bool
17651                                 Replaceable  bool
17652                                 OnRightClick bool
17653
17654                                 DmgPerSec int32
17655
17656                                 LiquidType   LiquidType
17657                                 FlowingAlt   string
17658                                 SrcAlt       string
17659                                 Viscosity    uint8 // 0-7
17660                                 LiqRenewable bool
17661                                 FlowRange    uint8
17662                                 DrownDmg     uint8
17663                                 Floodable    bool
17664
17665                                 DrawBox, ColBox, SelBox NodeBox
17666
17667                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17668
17669                                 LegacyFaceDir bool
17670                                 LegacyMounted bool
17671
17672                                 DigPredict string
17673
17674                                 MaxLvl uint8
17675
17676                                 AlphaUse
17677
17678                                 MoveResistance uint8
17679
17680                                 LiquidMovePhysics bool
17681                         }))(obj)).SrcAlt))))
17682                         write16(w, uint16(x))
17683                 }
17684                 {
17685                         _, err := w.Write(([]byte((*(*(struct {
17686                                 Param0 Content
17687
17688                                 Name   string
17689                                 Groups []Group
17690
17691                                 P1Type   Param1Type
17692                                 P2Type   Param2Type
17693                                 DrawType DrawType
17694
17695                                 Mesh  string
17696                                 Scale float32
17697                                 //mt:const uint8(6)
17698                                 Tiles        [6]TileDef
17699                                 OverlayTiles [6]TileDef
17700                                 //mt:const uint8(6)
17701                                 SpecialTiles [6]TileDef
17702
17703                                 Color   color.NRGBA
17704                                 Palette Texture
17705
17706                                 Waving       WaveType
17707                                 ConnectSides uint8
17708                                 ConnectTo    []Content
17709                                 InsideTint   color.NRGBA
17710                                 Level        uint8 // Must be < 128.
17711
17712                                 Translucent bool // Sunlight is scattered and becomes normal light.
17713                                 Transparent bool // Sunlight isn't scattered.
17714                                 LightSrc    uint8
17715
17716                                 GndContent   bool
17717                                 Collides     bool
17718                                 Pointable    bool
17719                                 Diggable     bool
17720                                 Climbable    bool
17721                                 Replaceable  bool
17722                                 OnRightClick bool
17723
17724                                 DmgPerSec int32
17725
17726                                 LiquidType   LiquidType
17727                                 FlowingAlt   string
17728                                 SrcAlt       string
17729                                 Viscosity    uint8 // 0-7
17730                                 LiqRenewable bool
17731                                 FlowRange    uint8
17732                                 DrownDmg     uint8
17733                                 Floodable    bool
17734
17735                                 DrawBox, ColBox, SelBox NodeBox
17736
17737                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17738
17739                                 LegacyFaceDir bool
17740                                 LegacyMounted bool
17741
17742                                 DigPredict string
17743
17744                                 MaxLvl uint8
17745
17746                                 AlphaUse
17747
17748                                 MoveResistance uint8
17749
17750                                 LiquidMovePhysics bool
17751                         }))(obj)).SrcAlt))[:])
17752                         chk(err)
17753                 }
17754                 {
17755                         x := (*(*(struct {
17756                                 Param0 Content
17757
17758                                 Name   string
17759                                 Groups []Group
17760
17761                                 P1Type   Param1Type
17762                                 P2Type   Param2Type
17763                                 DrawType DrawType
17764
17765                                 Mesh  string
17766                                 Scale float32
17767                                 //mt:const uint8(6)
17768                                 Tiles        [6]TileDef
17769                                 OverlayTiles [6]TileDef
17770                                 //mt:const uint8(6)
17771                                 SpecialTiles [6]TileDef
17772
17773                                 Color   color.NRGBA
17774                                 Palette Texture
17775
17776                                 Waving       WaveType
17777                                 ConnectSides uint8
17778                                 ConnectTo    []Content
17779                                 InsideTint   color.NRGBA
17780                                 Level        uint8 // Must be < 128.
17781
17782                                 Translucent bool // Sunlight is scattered and becomes normal light.
17783                                 Transparent bool // Sunlight isn't scattered.
17784                                 LightSrc    uint8
17785
17786                                 GndContent   bool
17787                                 Collides     bool
17788                                 Pointable    bool
17789                                 Diggable     bool
17790                                 Climbable    bool
17791                                 Replaceable  bool
17792                                 OnRightClick bool
17793
17794                                 DmgPerSec int32
17795
17796                                 LiquidType   LiquidType
17797                                 FlowingAlt   string
17798                                 SrcAlt       string
17799                                 Viscosity    uint8 // 0-7
17800                                 LiqRenewable bool
17801                                 FlowRange    uint8
17802                                 DrownDmg     uint8
17803                                 Floodable    bool
17804
17805                                 DrawBox, ColBox, SelBox NodeBox
17806
17807                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17808
17809                                 LegacyFaceDir bool
17810                                 LegacyMounted bool
17811
17812                                 DigPredict string
17813
17814                                 MaxLvl uint8
17815
17816                                 AlphaUse
17817
17818                                 MoveResistance uint8
17819
17820                                 LiquidMovePhysics bool
17821                         }))(obj)).Viscosity
17822                         write8(w, uint8(x))
17823                 }
17824                 {
17825                         x := (*(*(struct {
17826                                 Param0 Content
17827
17828                                 Name   string
17829                                 Groups []Group
17830
17831                                 P1Type   Param1Type
17832                                 P2Type   Param2Type
17833                                 DrawType DrawType
17834
17835                                 Mesh  string
17836                                 Scale float32
17837                                 //mt:const uint8(6)
17838                                 Tiles        [6]TileDef
17839                                 OverlayTiles [6]TileDef
17840                                 //mt:const uint8(6)
17841                                 SpecialTiles [6]TileDef
17842
17843                                 Color   color.NRGBA
17844                                 Palette Texture
17845
17846                                 Waving       WaveType
17847                                 ConnectSides uint8
17848                                 ConnectTo    []Content
17849                                 InsideTint   color.NRGBA
17850                                 Level        uint8 // Must be < 128.
17851
17852                                 Translucent bool // Sunlight is scattered and becomes normal light.
17853                                 Transparent bool // Sunlight isn't scattered.
17854                                 LightSrc    uint8
17855
17856                                 GndContent   bool
17857                                 Collides     bool
17858                                 Pointable    bool
17859                                 Diggable     bool
17860                                 Climbable    bool
17861                                 Replaceable  bool
17862                                 OnRightClick bool
17863
17864                                 DmgPerSec int32
17865
17866                                 LiquidType   LiquidType
17867                                 FlowingAlt   string
17868                                 SrcAlt       string
17869                                 Viscosity    uint8 // 0-7
17870                                 LiqRenewable bool
17871                                 FlowRange    uint8
17872                                 DrownDmg     uint8
17873                                 Floodable    bool
17874
17875                                 DrawBox, ColBox, SelBox NodeBox
17876
17877                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17878
17879                                 LegacyFaceDir bool
17880                                 LegacyMounted bool
17881
17882                                 DigPredict string
17883
17884                                 MaxLvl uint8
17885
17886                                 AlphaUse
17887
17888                                 MoveResistance uint8
17889
17890                                 LiquidMovePhysics bool
17891                         }))(obj)).LiqRenewable
17892                         if x {
17893                                 write8(w, 1)
17894                         } else {
17895                                 write8(w, 0)
17896                         }
17897                 }
17898                 {
17899                         x := (*(*(struct {
17900                                 Param0 Content
17901
17902                                 Name   string
17903                                 Groups []Group
17904
17905                                 P1Type   Param1Type
17906                                 P2Type   Param2Type
17907                                 DrawType DrawType
17908
17909                                 Mesh  string
17910                                 Scale float32
17911                                 //mt:const uint8(6)
17912                                 Tiles        [6]TileDef
17913                                 OverlayTiles [6]TileDef
17914                                 //mt:const uint8(6)
17915                                 SpecialTiles [6]TileDef
17916
17917                                 Color   color.NRGBA
17918                                 Palette Texture
17919
17920                                 Waving       WaveType
17921                                 ConnectSides uint8
17922                                 ConnectTo    []Content
17923                                 InsideTint   color.NRGBA
17924                                 Level        uint8 // Must be < 128.
17925
17926                                 Translucent bool // Sunlight is scattered and becomes normal light.
17927                                 Transparent bool // Sunlight isn't scattered.
17928                                 LightSrc    uint8
17929
17930                                 GndContent   bool
17931                                 Collides     bool
17932                                 Pointable    bool
17933                                 Diggable     bool
17934                                 Climbable    bool
17935                                 Replaceable  bool
17936                                 OnRightClick bool
17937
17938                                 DmgPerSec int32
17939
17940                                 LiquidType   LiquidType
17941                                 FlowingAlt   string
17942                                 SrcAlt       string
17943                                 Viscosity    uint8 // 0-7
17944                                 LiqRenewable bool
17945                                 FlowRange    uint8
17946                                 DrownDmg     uint8
17947                                 Floodable    bool
17948
17949                                 DrawBox, ColBox, SelBox NodeBox
17950
17951                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17952
17953                                 LegacyFaceDir bool
17954                                 LegacyMounted bool
17955
17956                                 DigPredict string
17957
17958                                 MaxLvl uint8
17959
17960                                 AlphaUse
17961
17962                                 MoveResistance uint8
17963
17964                                 LiquidMovePhysics bool
17965                         }))(obj)).FlowRange
17966                         write8(w, uint8(x))
17967                 }
17968                 {
17969                         x := (*(*(struct {
17970                                 Param0 Content
17971
17972                                 Name   string
17973                                 Groups []Group
17974
17975                                 P1Type   Param1Type
17976                                 P2Type   Param2Type
17977                                 DrawType DrawType
17978
17979                                 Mesh  string
17980                                 Scale float32
17981                                 //mt:const uint8(6)
17982                                 Tiles        [6]TileDef
17983                                 OverlayTiles [6]TileDef
17984                                 //mt:const uint8(6)
17985                                 SpecialTiles [6]TileDef
17986
17987                                 Color   color.NRGBA
17988                                 Palette Texture
17989
17990                                 Waving       WaveType
17991                                 ConnectSides uint8
17992                                 ConnectTo    []Content
17993                                 InsideTint   color.NRGBA
17994                                 Level        uint8 // Must be < 128.
17995
17996                                 Translucent bool // Sunlight is scattered and becomes normal light.
17997                                 Transparent bool // Sunlight isn't scattered.
17998                                 LightSrc    uint8
17999
18000                                 GndContent   bool
18001                                 Collides     bool
18002                                 Pointable    bool
18003                                 Diggable     bool
18004                                 Climbable    bool
18005                                 Replaceable  bool
18006                                 OnRightClick bool
18007
18008                                 DmgPerSec int32
18009
18010                                 LiquidType   LiquidType
18011                                 FlowingAlt   string
18012                                 SrcAlt       string
18013                                 Viscosity    uint8 // 0-7
18014                                 LiqRenewable bool
18015                                 FlowRange    uint8
18016                                 DrownDmg     uint8
18017                                 Floodable    bool
18018
18019                                 DrawBox, ColBox, SelBox NodeBox
18020
18021                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18022
18023                                 LegacyFaceDir bool
18024                                 LegacyMounted bool
18025
18026                                 DigPredict string
18027
18028                                 MaxLvl uint8
18029
18030                                 AlphaUse
18031
18032                                 MoveResistance uint8
18033
18034                                 LiquidMovePhysics bool
18035                         }))(obj)).DrownDmg
18036                         write8(w, uint8(x))
18037                 }
18038                 {
18039                         x := (*(*(struct {
18040                                 Param0 Content
18041
18042                                 Name   string
18043                                 Groups []Group
18044
18045                                 P1Type   Param1Type
18046                                 P2Type   Param2Type
18047                                 DrawType DrawType
18048
18049                                 Mesh  string
18050                                 Scale float32
18051                                 //mt:const uint8(6)
18052                                 Tiles        [6]TileDef
18053                                 OverlayTiles [6]TileDef
18054                                 //mt:const uint8(6)
18055                                 SpecialTiles [6]TileDef
18056
18057                                 Color   color.NRGBA
18058                                 Palette Texture
18059
18060                                 Waving       WaveType
18061                                 ConnectSides uint8
18062                                 ConnectTo    []Content
18063                                 InsideTint   color.NRGBA
18064                                 Level        uint8 // Must be < 128.
18065
18066                                 Translucent bool // Sunlight is scattered and becomes normal light.
18067                                 Transparent bool // Sunlight isn't scattered.
18068                                 LightSrc    uint8
18069
18070                                 GndContent   bool
18071                                 Collides     bool
18072                                 Pointable    bool
18073                                 Diggable     bool
18074                                 Climbable    bool
18075                                 Replaceable  bool
18076                                 OnRightClick bool
18077
18078                                 DmgPerSec int32
18079
18080                                 LiquidType   LiquidType
18081                                 FlowingAlt   string
18082                                 SrcAlt       string
18083                                 Viscosity    uint8 // 0-7
18084                                 LiqRenewable bool
18085                                 FlowRange    uint8
18086                                 DrownDmg     uint8
18087                                 Floodable    bool
18088
18089                                 DrawBox, ColBox, SelBox NodeBox
18090
18091                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18092
18093                                 LegacyFaceDir bool
18094                                 LegacyMounted bool
18095
18096                                 DigPredict string
18097
18098                                 MaxLvl uint8
18099
18100                                 AlphaUse
18101
18102                                 MoveResistance uint8
18103
18104                                 LiquidMovePhysics bool
18105                         }))(obj)).Floodable
18106                         if x {
18107                                 write8(w, 1)
18108                         } else {
18109                                 write8(w, 0)
18110                         }
18111                 }
18112                 if err := pcall(func() {
18113                         ((*(*(struct {
18114                                 Param0 Content
18115
18116                                 Name   string
18117                                 Groups []Group
18118
18119                                 P1Type   Param1Type
18120                                 P2Type   Param2Type
18121                                 DrawType DrawType
18122
18123                                 Mesh  string
18124                                 Scale float32
18125                                 //mt:const uint8(6)
18126                                 Tiles        [6]TileDef
18127                                 OverlayTiles [6]TileDef
18128                                 //mt:const uint8(6)
18129                                 SpecialTiles [6]TileDef
18130
18131                                 Color   color.NRGBA
18132                                 Palette Texture
18133
18134                                 Waving       WaveType
18135                                 ConnectSides uint8
18136                                 ConnectTo    []Content
18137                                 InsideTint   color.NRGBA
18138                                 Level        uint8 // Must be < 128.
18139
18140                                 Translucent bool // Sunlight is scattered and becomes normal light.
18141                                 Transparent bool // Sunlight isn't scattered.
18142                                 LightSrc    uint8
18143
18144                                 GndContent   bool
18145                                 Collides     bool
18146                                 Pointable    bool
18147                                 Diggable     bool
18148                                 Climbable    bool
18149                                 Replaceable  bool
18150                                 OnRightClick bool
18151
18152                                 DmgPerSec int32
18153
18154                                 LiquidType   LiquidType
18155                                 FlowingAlt   string
18156                                 SrcAlt       string
18157                                 Viscosity    uint8 // 0-7
18158                                 LiqRenewable bool
18159                                 FlowRange    uint8
18160                                 DrownDmg     uint8
18161                                 Floodable    bool
18162
18163                                 DrawBox, ColBox, SelBox NodeBox
18164
18165                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18166
18167                                 LegacyFaceDir bool
18168                                 LegacyMounted bool
18169
18170                                 DigPredict string
18171
18172                                 MaxLvl uint8
18173
18174                                 AlphaUse
18175
18176                                 MoveResistance uint8
18177
18178                                 LiquidMovePhysics bool
18179                         }))(obj)).DrawBox).Serialize(w)
18180                 }); err != nil {
18181                         if err == io.EOF {
18182                                 chk(io.EOF)
18183                         }
18184                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18185                 }
18186                 if err := pcall(func() {
18187                         ((*(*(struct {
18188                                 Param0 Content
18189
18190                                 Name   string
18191                                 Groups []Group
18192
18193                                 P1Type   Param1Type
18194                                 P2Type   Param2Type
18195                                 DrawType DrawType
18196
18197                                 Mesh  string
18198                                 Scale float32
18199                                 //mt:const uint8(6)
18200                                 Tiles        [6]TileDef
18201                                 OverlayTiles [6]TileDef
18202                                 //mt:const uint8(6)
18203                                 SpecialTiles [6]TileDef
18204
18205                                 Color   color.NRGBA
18206                                 Palette Texture
18207
18208                                 Waving       WaveType
18209                                 ConnectSides uint8
18210                                 ConnectTo    []Content
18211                                 InsideTint   color.NRGBA
18212                                 Level        uint8 // Must be < 128.
18213
18214                                 Translucent bool // Sunlight is scattered and becomes normal light.
18215                                 Transparent bool // Sunlight isn't scattered.
18216                                 LightSrc    uint8
18217
18218                                 GndContent   bool
18219                                 Collides     bool
18220                                 Pointable    bool
18221                                 Diggable     bool
18222                                 Climbable    bool
18223                                 Replaceable  bool
18224                                 OnRightClick bool
18225
18226                                 DmgPerSec int32
18227
18228                                 LiquidType   LiquidType
18229                                 FlowingAlt   string
18230                                 SrcAlt       string
18231                                 Viscosity    uint8 // 0-7
18232                                 LiqRenewable bool
18233                                 FlowRange    uint8
18234                                 DrownDmg     uint8
18235                                 Floodable    bool
18236
18237                                 DrawBox, ColBox, SelBox NodeBox
18238
18239                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18240
18241                                 LegacyFaceDir bool
18242                                 LegacyMounted bool
18243
18244                                 DigPredict string
18245
18246                                 MaxLvl uint8
18247
18248                                 AlphaUse
18249
18250                                 MoveResistance uint8
18251
18252                                 LiquidMovePhysics bool
18253                         }))(obj)).ColBox).Serialize(w)
18254                 }); err != nil {
18255                         if err == io.EOF {
18256                                 chk(io.EOF)
18257                         }
18258                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18259                 }
18260                 if err := pcall(func() {
18261                         ((*(*(struct {
18262                                 Param0 Content
18263
18264                                 Name   string
18265                                 Groups []Group
18266
18267                                 P1Type   Param1Type
18268                                 P2Type   Param2Type
18269                                 DrawType DrawType
18270
18271                                 Mesh  string
18272                                 Scale float32
18273                                 //mt:const uint8(6)
18274                                 Tiles        [6]TileDef
18275                                 OverlayTiles [6]TileDef
18276                                 //mt:const uint8(6)
18277                                 SpecialTiles [6]TileDef
18278
18279                                 Color   color.NRGBA
18280                                 Palette Texture
18281
18282                                 Waving       WaveType
18283                                 ConnectSides uint8
18284                                 ConnectTo    []Content
18285                                 InsideTint   color.NRGBA
18286                                 Level        uint8 // Must be < 128.
18287
18288                                 Translucent bool // Sunlight is scattered and becomes normal light.
18289                                 Transparent bool // Sunlight isn't scattered.
18290                                 LightSrc    uint8
18291
18292                                 GndContent   bool
18293                                 Collides     bool
18294                                 Pointable    bool
18295                                 Diggable     bool
18296                                 Climbable    bool
18297                                 Replaceable  bool
18298                                 OnRightClick bool
18299
18300                                 DmgPerSec int32
18301
18302                                 LiquidType   LiquidType
18303                                 FlowingAlt   string
18304                                 SrcAlt       string
18305                                 Viscosity    uint8 // 0-7
18306                                 LiqRenewable bool
18307                                 FlowRange    uint8
18308                                 DrownDmg     uint8
18309                                 Floodable    bool
18310
18311                                 DrawBox, ColBox, SelBox NodeBox
18312
18313                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18314
18315                                 LegacyFaceDir bool
18316                                 LegacyMounted bool
18317
18318                                 DigPredict string
18319
18320                                 MaxLvl uint8
18321
18322                                 AlphaUse
18323
18324                                 MoveResistance uint8
18325
18326                                 LiquidMovePhysics bool
18327                         }))(obj)).SelBox).Serialize(w)
18328                 }); err != nil {
18329                         if err == io.EOF {
18330                                 chk(io.EOF)
18331                         }
18332                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18333                 }
18334                 if err := pcall(func() {
18335                         ((*(*(struct {
18336                                 Param0 Content
18337
18338                                 Name   string
18339                                 Groups []Group
18340
18341                                 P1Type   Param1Type
18342                                 P2Type   Param2Type
18343                                 DrawType DrawType
18344
18345                                 Mesh  string
18346                                 Scale float32
18347                                 //mt:const uint8(6)
18348                                 Tiles        [6]TileDef
18349                                 OverlayTiles [6]TileDef
18350                                 //mt:const uint8(6)
18351                                 SpecialTiles [6]TileDef
18352
18353                                 Color   color.NRGBA
18354                                 Palette Texture
18355
18356                                 Waving       WaveType
18357                                 ConnectSides uint8
18358                                 ConnectTo    []Content
18359                                 InsideTint   color.NRGBA
18360                                 Level        uint8 // Must be < 128.
18361
18362                                 Translucent bool // Sunlight is scattered and becomes normal light.
18363                                 Transparent bool // Sunlight isn't scattered.
18364                                 LightSrc    uint8
18365
18366                                 GndContent   bool
18367                                 Collides     bool
18368                                 Pointable    bool
18369                                 Diggable     bool
18370                                 Climbable    bool
18371                                 Replaceable  bool
18372                                 OnRightClick bool
18373
18374                                 DmgPerSec int32
18375
18376                                 LiquidType   LiquidType
18377                                 FlowingAlt   string
18378                                 SrcAlt       string
18379                                 Viscosity    uint8 // 0-7
18380                                 LiqRenewable bool
18381                                 FlowRange    uint8
18382                                 DrownDmg     uint8
18383                                 Floodable    bool
18384
18385                                 DrawBox, ColBox, SelBox NodeBox
18386
18387                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18388
18389                                 LegacyFaceDir bool
18390                                 LegacyMounted bool
18391
18392                                 DigPredict string
18393
18394                                 MaxLvl uint8
18395
18396                                 AlphaUse
18397
18398                                 MoveResistance uint8
18399
18400                                 LiquidMovePhysics bool
18401                         }))(obj)).FootstepSnd).Serialize(w)
18402                 }); err != nil {
18403                         if err == io.EOF {
18404                                 chk(io.EOF)
18405                         }
18406                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18407                 }
18408                 if err := pcall(func() {
18409                         ((*(*(struct {
18410                                 Param0 Content
18411
18412                                 Name   string
18413                                 Groups []Group
18414
18415                                 P1Type   Param1Type
18416                                 P2Type   Param2Type
18417                                 DrawType DrawType
18418
18419                                 Mesh  string
18420                                 Scale float32
18421                                 //mt:const uint8(6)
18422                                 Tiles        [6]TileDef
18423                                 OverlayTiles [6]TileDef
18424                                 //mt:const uint8(6)
18425                                 SpecialTiles [6]TileDef
18426
18427                                 Color   color.NRGBA
18428                                 Palette Texture
18429
18430                                 Waving       WaveType
18431                                 ConnectSides uint8
18432                                 ConnectTo    []Content
18433                                 InsideTint   color.NRGBA
18434                                 Level        uint8 // Must be < 128.
18435
18436                                 Translucent bool // Sunlight is scattered and becomes normal light.
18437                                 Transparent bool // Sunlight isn't scattered.
18438                                 LightSrc    uint8
18439
18440                                 GndContent   bool
18441                                 Collides     bool
18442                                 Pointable    bool
18443                                 Diggable     bool
18444                                 Climbable    bool
18445                                 Replaceable  bool
18446                                 OnRightClick bool
18447
18448                                 DmgPerSec int32
18449
18450                                 LiquidType   LiquidType
18451                                 FlowingAlt   string
18452                                 SrcAlt       string
18453                                 Viscosity    uint8 // 0-7
18454                                 LiqRenewable bool
18455                                 FlowRange    uint8
18456                                 DrownDmg     uint8
18457                                 Floodable    bool
18458
18459                                 DrawBox, ColBox, SelBox NodeBox
18460
18461                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18462
18463                                 LegacyFaceDir bool
18464                                 LegacyMounted bool
18465
18466                                 DigPredict string
18467
18468                                 MaxLvl uint8
18469
18470                                 AlphaUse
18471
18472                                 MoveResistance uint8
18473
18474                                 LiquidMovePhysics bool
18475                         }))(obj)).DiggingSnd).Serialize(w)
18476                 }); err != nil {
18477                         if err == io.EOF {
18478                                 chk(io.EOF)
18479                         }
18480                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18481                 }
18482                 if err := pcall(func() {
18483                         ((*(*(struct {
18484                                 Param0 Content
18485
18486                                 Name   string
18487                                 Groups []Group
18488
18489                                 P1Type   Param1Type
18490                                 P2Type   Param2Type
18491                                 DrawType DrawType
18492
18493                                 Mesh  string
18494                                 Scale float32
18495                                 //mt:const uint8(6)
18496                                 Tiles        [6]TileDef
18497                                 OverlayTiles [6]TileDef
18498                                 //mt:const uint8(6)
18499                                 SpecialTiles [6]TileDef
18500
18501                                 Color   color.NRGBA
18502                                 Palette Texture
18503
18504                                 Waving       WaveType
18505                                 ConnectSides uint8
18506                                 ConnectTo    []Content
18507                                 InsideTint   color.NRGBA
18508                                 Level        uint8 // Must be < 128.
18509
18510                                 Translucent bool // Sunlight is scattered and becomes normal light.
18511                                 Transparent bool // Sunlight isn't scattered.
18512                                 LightSrc    uint8
18513
18514                                 GndContent   bool
18515                                 Collides     bool
18516                                 Pointable    bool
18517                                 Diggable     bool
18518                                 Climbable    bool
18519                                 Replaceable  bool
18520                                 OnRightClick bool
18521
18522                                 DmgPerSec int32
18523
18524                                 LiquidType   LiquidType
18525                                 FlowingAlt   string
18526                                 SrcAlt       string
18527                                 Viscosity    uint8 // 0-7
18528                                 LiqRenewable bool
18529                                 FlowRange    uint8
18530                                 DrownDmg     uint8
18531                                 Floodable    bool
18532
18533                                 DrawBox, ColBox, SelBox NodeBox
18534
18535                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18536
18537                                 LegacyFaceDir bool
18538                                 LegacyMounted bool
18539
18540                                 DigPredict string
18541
18542                                 MaxLvl uint8
18543
18544                                 AlphaUse
18545
18546                                 MoveResistance uint8
18547
18548                                 LiquidMovePhysics bool
18549                         }))(obj)).DugSnd).Serialize(w)
18550                 }); err != nil {
18551                         if err == io.EOF {
18552                                 chk(io.EOF)
18553                         }
18554                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18555                 }
18556                 {
18557                         x := (*(*(struct {
18558                                 Param0 Content
18559
18560                                 Name   string
18561                                 Groups []Group
18562
18563                                 P1Type   Param1Type
18564                                 P2Type   Param2Type
18565                                 DrawType DrawType
18566
18567                                 Mesh  string
18568                                 Scale float32
18569                                 //mt:const uint8(6)
18570                                 Tiles        [6]TileDef
18571                                 OverlayTiles [6]TileDef
18572                                 //mt:const uint8(6)
18573                                 SpecialTiles [6]TileDef
18574
18575                                 Color   color.NRGBA
18576                                 Palette Texture
18577
18578                                 Waving       WaveType
18579                                 ConnectSides uint8
18580                                 ConnectTo    []Content
18581                                 InsideTint   color.NRGBA
18582                                 Level        uint8 // Must be < 128.
18583
18584                                 Translucent bool // Sunlight is scattered and becomes normal light.
18585                                 Transparent bool // Sunlight isn't scattered.
18586                                 LightSrc    uint8
18587
18588                                 GndContent   bool
18589                                 Collides     bool
18590                                 Pointable    bool
18591                                 Diggable     bool
18592                                 Climbable    bool
18593                                 Replaceable  bool
18594                                 OnRightClick bool
18595
18596                                 DmgPerSec int32
18597
18598                                 LiquidType   LiquidType
18599                                 FlowingAlt   string
18600                                 SrcAlt       string
18601                                 Viscosity    uint8 // 0-7
18602                                 LiqRenewable bool
18603                                 FlowRange    uint8
18604                                 DrownDmg     uint8
18605                                 Floodable    bool
18606
18607                                 DrawBox, ColBox, SelBox NodeBox
18608
18609                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18610
18611                                 LegacyFaceDir bool
18612                                 LegacyMounted bool
18613
18614                                 DigPredict string
18615
18616                                 MaxLvl uint8
18617
18618                                 AlphaUse
18619
18620                                 MoveResistance uint8
18621
18622                                 LiquidMovePhysics bool
18623                         }))(obj)).LegacyFaceDir
18624                         if x {
18625                                 write8(w, 1)
18626                         } else {
18627                                 write8(w, 0)
18628                         }
18629                 }
18630                 {
18631                         x := (*(*(struct {
18632                                 Param0 Content
18633
18634                                 Name   string
18635                                 Groups []Group
18636
18637                                 P1Type   Param1Type
18638                                 P2Type   Param2Type
18639                                 DrawType DrawType
18640
18641                                 Mesh  string
18642                                 Scale float32
18643                                 //mt:const uint8(6)
18644                                 Tiles        [6]TileDef
18645                                 OverlayTiles [6]TileDef
18646                                 //mt:const uint8(6)
18647                                 SpecialTiles [6]TileDef
18648
18649                                 Color   color.NRGBA
18650                                 Palette Texture
18651
18652                                 Waving       WaveType
18653                                 ConnectSides uint8
18654                                 ConnectTo    []Content
18655                                 InsideTint   color.NRGBA
18656                                 Level        uint8 // Must be < 128.
18657
18658                                 Translucent bool // Sunlight is scattered and becomes normal light.
18659                                 Transparent bool // Sunlight isn't scattered.
18660                                 LightSrc    uint8
18661
18662                                 GndContent   bool
18663                                 Collides     bool
18664                                 Pointable    bool
18665                                 Diggable     bool
18666                                 Climbable    bool
18667                                 Replaceable  bool
18668                                 OnRightClick bool
18669
18670                                 DmgPerSec int32
18671
18672                                 LiquidType   LiquidType
18673                                 FlowingAlt   string
18674                                 SrcAlt       string
18675                                 Viscosity    uint8 // 0-7
18676                                 LiqRenewable bool
18677                                 FlowRange    uint8
18678                                 DrownDmg     uint8
18679                                 Floodable    bool
18680
18681                                 DrawBox, ColBox, SelBox NodeBox
18682
18683                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18684
18685                                 LegacyFaceDir bool
18686                                 LegacyMounted bool
18687
18688                                 DigPredict string
18689
18690                                 MaxLvl uint8
18691
18692                                 AlphaUse
18693
18694                                 MoveResistance uint8
18695
18696                                 LiquidMovePhysics bool
18697                         }))(obj)).LegacyMounted
18698                         if x {
18699                                 write8(w, 1)
18700                         } else {
18701                                 write8(w, 0)
18702                         }
18703                 }
18704                 if len(([]byte((*(*(struct {
18705                         Param0 Content
18706
18707                         Name   string
18708                         Groups []Group
18709
18710                         P1Type   Param1Type
18711                         P2Type   Param2Type
18712                         DrawType DrawType
18713
18714                         Mesh  string
18715                         Scale float32
18716                         //mt:const uint8(6)
18717                         Tiles        [6]TileDef
18718                         OverlayTiles [6]TileDef
18719                         //mt:const uint8(6)
18720                         SpecialTiles [6]TileDef
18721
18722                         Color   color.NRGBA
18723                         Palette Texture
18724
18725                         Waving       WaveType
18726                         ConnectSides uint8
18727                         ConnectTo    []Content
18728                         InsideTint   color.NRGBA
18729                         Level        uint8 // Must be < 128.
18730
18731                         Translucent bool // Sunlight is scattered and becomes normal light.
18732                         Transparent bool // Sunlight isn't scattered.
18733                         LightSrc    uint8
18734
18735                         GndContent   bool
18736                         Collides     bool
18737                         Pointable    bool
18738                         Diggable     bool
18739                         Climbable    bool
18740                         Replaceable  bool
18741                         OnRightClick bool
18742
18743                         DmgPerSec int32
18744
18745                         LiquidType   LiquidType
18746                         FlowingAlt   string
18747                         SrcAlt       string
18748                         Viscosity    uint8 // 0-7
18749                         LiqRenewable bool
18750                         FlowRange    uint8
18751                         DrownDmg     uint8
18752                         Floodable    bool
18753
18754                         DrawBox, ColBox, SelBox NodeBox
18755
18756                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18757
18758                         LegacyFaceDir bool
18759                         LegacyMounted bool
18760
18761                         DigPredict string
18762
18763                         MaxLvl uint8
18764
18765                         AlphaUse
18766
18767                         MoveResistance uint8
18768
18769                         LiquidMovePhysics bool
18770                 }))(obj)).DigPredict))) > math.MaxUint16 {
18771                         chk(ErrTooLong)
18772                 }
18773                 {
18774                         x := uint16(len(([]byte((*(*(struct {
18775                                 Param0 Content
18776
18777                                 Name   string
18778                                 Groups []Group
18779
18780                                 P1Type   Param1Type
18781                                 P2Type   Param2Type
18782                                 DrawType DrawType
18783
18784                                 Mesh  string
18785                                 Scale float32
18786                                 //mt:const uint8(6)
18787                                 Tiles        [6]TileDef
18788                                 OverlayTiles [6]TileDef
18789                                 //mt:const uint8(6)
18790                                 SpecialTiles [6]TileDef
18791
18792                                 Color   color.NRGBA
18793                                 Palette Texture
18794
18795                                 Waving       WaveType
18796                                 ConnectSides uint8
18797                                 ConnectTo    []Content
18798                                 InsideTint   color.NRGBA
18799                                 Level        uint8 // Must be < 128.
18800
18801                                 Translucent bool // Sunlight is scattered and becomes normal light.
18802                                 Transparent bool // Sunlight isn't scattered.
18803                                 LightSrc    uint8
18804
18805                                 GndContent   bool
18806                                 Collides     bool
18807                                 Pointable    bool
18808                                 Diggable     bool
18809                                 Climbable    bool
18810                                 Replaceable  bool
18811                                 OnRightClick bool
18812
18813                                 DmgPerSec int32
18814
18815                                 LiquidType   LiquidType
18816                                 FlowingAlt   string
18817                                 SrcAlt       string
18818                                 Viscosity    uint8 // 0-7
18819                                 LiqRenewable bool
18820                                 FlowRange    uint8
18821                                 DrownDmg     uint8
18822                                 Floodable    bool
18823
18824                                 DrawBox, ColBox, SelBox NodeBox
18825
18826                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18827
18828                                 LegacyFaceDir bool
18829                                 LegacyMounted bool
18830
18831                                 DigPredict string
18832
18833                                 MaxLvl uint8
18834
18835                                 AlphaUse
18836
18837                                 MoveResistance uint8
18838
18839                                 LiquidMovePhysics bool
18840                         }))(obj)).DigPredict))))
18841                         write16(w, uint16(x))
18842                 }
18843                 {
18844                         _, err := w.Write(([]byte((*(*(struct {
18845                                 Param0 Content
18846
18847                                 Name   string
18848                                 Groups []Group
18849
18850                                 P1Type   Param1Type
18851                                 P2Type   Param2Type
18852                                 DrawType DrawType
18853
18854                                 Mesh  string
18855                                 Scale float32
18856                                 //mt:const uint8(6)
18857                                 Tiles        [6]TileDef
18858                                 OverlayTiles [6]TileDef
18859                                 //mt:const uint8(6)
18860                                 SpecialTiles [6]TileDef
18861
18862                                 Color   color.NRGBA
18863                                 Palette Texture
18864
18865                                 Waving       WaveType
18866                                 ConnectSides uint8
18867                                 ConnectTo    []Content
18868                                 InsideTint   color.NRGBA
18869                                 Level        uint8 // Must be < 128.
18870
18871                                 Translucent bool // Sunlight is scattered and becomes normal light.
18872                                 Transparent bool // Sunlight isn't scattered.
18873                                 LightSrc    uint8
18874
18875                                 GndContent   bool
18876                                 Collides     bool
18877                                 Pointable    bool
18878                                 Diggable     bool
18879                                 Climbable    bool
18880                                 Replaceable  bool
18881                                 OnRightClick bool
18882
18883                                 DmgPerSec int32
18884
18885                                 LiquidType   LiquidType
18886                                 FlowingAlt   string
18887                                 SrcAlt       string
18888                                 Viscosity    uint8 // 0-7
18889                                 LiqRenewable bool
18890                                 FlowRange    uint8
18891                                 DrownDmg     uint8
18892                                 Floodable    bool
18893
18894                                 DrawBox, ColBox, SelBox NodeBox
18895
18896                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18897
18898                                 LegacyFaceDir bool
18899                                 LegacyMounted bool
18900
18901                                 DigPredict string
18902
18903                                 MaxLvl uint8
18904
18905                                 AlphaUse
18906
18907                                 MoveResistance uint8
18908
18909                                 LiquidMovePhysics bool
18910                         }))(obj)).DigPredict))[:])
18911                         chk(err)
18912                 }
18913                 {
18914                         x := (*(*(struct {
18915                                 Param0 Content
18916
18917                                 Name   string
18918                                 Groups []Group
18919
18920                                 P1Type   Param1Type
18921                                 P2Type   Param2Type
18922                                 DrawType DrawType
18923
18924                                 Mesh  string
18925                                 Scale float32
18926                                 //mt:const uint8(6)
18927                                 Tiles        [6]TileDef
18928                                 OverlayTiles [6]TileDef
18929                                 //mt:const uint8(6)
18930                                 SpecialTiles [6]TileDef
18931
18932                                 Color   color.NRGBA
18933                                 Palette Texture
18934
18935                                 Waving       WaveType
18936                                 ConnectSides uint8
18937                                 ConnectTo    []Content
18938                                 InsideTint   color.NRGBA
18939                                 Level        uint8 // Must be < 128.
18940
18941                                 Translucent bool // Sunlight is scattered and becomes normal light.
18942                                 Transparent bool // Sunlight isn't scattered.
18943                                 LightSrc    uint8
18944
18945                                 GndContent   bool
18946                                 Collides     bool
18947                                 Pointable    bool
18948                                 Diggable     bool
18949                                 Climbable    bool
18950                                 Replaceable  bool
18951                                 OnRightClick bool
18952
18953                                 DmgPerSec int32
18954
18955                                 LiquidType   LiquidType
18956                                 FlowingAlt   string
18957                                 SrcAlt       string
18958                                 Viscosity    uint8 // 0-7
18959                                 LiqRenewable bool
18960                                 FlowRange    uint8
18961                                 DrownDmg     uint8
18962                                 Floodable    bool
18963
18964                                 DrawBox, ColBox, SelBox NodeBox
18965
18966                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18967
18968                                 LegacyFaceDir bool
18969                                 LegacyMounted bool
18970
18971                                 DigPredict string
18972
18973                                 MaxLvl uint8
18974
18975                                 AlphaUse
18976
18977                                 MoveResistance uint8
18978
18979                                 LiquidMovePhysics bool
18980                         }))(obj)).MaxLvl
18981                         write8(w, uint8(x))
18982                 }
18983                 if err := pcall(func() {
18984                         ((*(*(struct {
18985                                 Param0 Content
18986
18987                                 Name   string
18988                                 Groups []Group
18989
18990                                 P1Type   Param1Type
18991                                 P2Type   Param2Type
18992                                 DrawType DrawType
18993
18994                                 Mesh  string
18995                                 Scale float32
18996                                 //mt:const uint8(6)
18997                                 Tiles        [6]TileDef
18998                                 OverlayTiles [6]TileDef
18999                                 //mt:const uint8(6)
19000                                 SpecialTiles [6]TileDef
19001
19002                                 Color   color.NRGBA
19003                                 Palette Texture
19004
19005                                 Waving       WaveType
19006                                 ConnectSides uint8
19007                                 ConnectTo    []Content
19008                                 InsideTint   color.NRGBA
19009                                 Level        uint8 // Must be < 128.
19010
19011                                 Translucent bool // Sunlight is scattered and becomes normal light.
19012                                 Transparent bool // Sunlight isn't scattered.
19013                                 LightSrc    uint8
19014
19015                                 GndContent   bool
19016                                 Collides     bool
19017                                 Pointable    bool
19018                                 Diggable     bool
19019                                 Climbable    bool
19020                                 Replaceable  bool
19021                                 OnRightClick bool
19022
19023                                 DmgPerSec int32
19024
19025                                 LiquidType   LiquidType
19026                                 FlowingAlt   string
19027                                 SrcAlt       string
19028                                 Viscosity    uint8 // 0-7
19029                                 LiqRenewable bool
19030                                 FlowRange    uint8
19031                                 DrownDmg     uint8
19032                                 Floodable    bool
19033
19034                                 DrawBox, ColBox, SelBox NodeBox
19035
19036                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19037
19038                                 LegacyFaceDir bool
19039                                 LegacyMounted bool
19040
19041                                 DigPredict string
19042
19043                                 MaxLvl uint8
19044
19045                                 AlphaUse
19046
19047                                 MoveResistance uint8
19048
19049                                 LiquidMovePhysics bool
19050                         }))(obj)).AlphaUse).Serialize(w)
19051                 }); err != nil {
19052                         if err == io.EOF {
19053                                 chk(io.EOF)
19054                         }
19055                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlphaUse", err))
19056                 }
19057                 {
19058                         x := (*(*(struct {
19059                                 Param0 Content
19060
19061                                 Name   string
19062                                 Groups []Group
19063
19064                                 P1Type   Param1Type
19065                                 P2Type   Param2Type
19066                                 DrawType DrawType
19067
19068                                 Mesh  string
19069                                 Scale float32
19070                                 //mt:const uint8(6)
19071                                 Tiles        [6]TileDef
19072                                 OverlayTiles [6]TileDef
19073                                 //mt:const uint8(6)
19074                                 SpecialTiles [6]TileDef
19075
19076                                 Color   color.NRGBA
19077                                 Palette Texture
19078
19079                                 Waving       WaveType
19080                                 ConnectSides uint8
19081                                 ConnectTo    []Content
19082                                 InsideTint   color.NRGBA
19083                                 Level        uint8 // Must be < 128.
19084
19085                                 Translucent bool // Sunlight is scattered and becomes normal light.
19086                                 Transparent bool // Sunlight isn't scattered.
19087                                 LightSrc    uint8
19088
19089                                 GndContent   bool
19090                                 Collides     bool
19091                                 Pointable    bool
19092                                 Diggable     bool
19093                                 Climbable    bool
19094                                 Replaceable  bool
19095                                 OnRightClick bool
19096
19097                                 DmgPerSec int32
19098
19099                                 LiquidType   LiquidType
19100                                 FlowingAlt   string
19101                                 SrcAlt       string
19102                                 Viscosity    uint8 // 0-7
19103                                 LiqRenewable bool
19104                                 FlowRange    uint8
19105                                 DrownDmg     uint8
19106                                 Floodable    bool
19107
19108                                 DrawBox, ColBox, SelBox NodeBox
19109
19110                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19111
19112                                 LegacyFaceDir bool
19113                                 LegacyMounted bool
19114
19115                                 DigPredict string
19116
19117                                 MaxLvl uint8
19118
19119                                 AlphaUse
19120
19121                                 MoveResistance uint8
19122
19123                                 LiquidMovePhysics bool
19124                         }))(obj)).MoveResistance
19125                         write8(w, uint8(x))
19126                 }
19127                 {
19128                         x := (*(*(struct {
19129                                 Param0 Content
19130
19131                                 Name   string
19132                                 Groups []Group
19133
19134                                 P1Type   Param1Type
19135                                 P2Type   Param2Type
19136                                 DrawType DrawType
19137
19138                                 Mesh  string
19139                                 Scale float32
19140                                 //mt:const uint8(6)
19141                                 Tiles        [6]TileDef
19142                                 OverlayTiles [6]TileDef
19143                                 //mt:const uint8(6)
19144                                 SpecialTiles [6]TileDef
19145
19146                                 Color   color.NRGBA
19147                                 Palette Texture
19148
19149                                 Waving       WaveType
19150                                 ConnectSides uint8
19151                                 ConnectTo    []Content
19152                                 InsideTint   color.NRGBA
19153                                 Level        uint8 // Must be < 128.
19154
19155                                 Translucent bool // Sunlight is scattered and becomes normal light.
19156                                 Transparent bool // Sunlight isn't scattered.
19157                                 LightSrc    uint8
19158
19159                                 GndContent   bool
19160                                 Collides     bool
19161                                 Pointable    bool
19162                                 Diggable     bool
19163                                 Climbable    bool
19164                                 Replaceable  bool
19165                                 OnRightClick bool
19166
19167                                 DmgPerSec int32
19168
19169                                 LiquidType   LiquidType
19170                                 FlowingAlt   string
19171                                 SrcAlt       string
19172                                 Viscosity    uint8 // 0-7
19173                                 LiqRenewable bool
19174                                 FlowRange    uint8
19175                                 DrownDmg     uint8
19176                                 Floodable    bool
19177
19178                                 DrawBox, ColBox, SelBox NodeBox
19179
19180                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19181
19182                                 LegacyFaceDir bool
19183                                 LegacyMounted bool
19184
19185                                 DigPredict string
19186
19187                                 MaxLvl uint8
19188
19189                                 AlphaUse
19190
19191                                 MoveResistance uint8
19192
19193                                 LiquidMovePhysics bool
19194                         }))(obj)).LiquidMovePhysics
19195                         if x {
19196                                 write8(w, 1)
19197                         } else {
19198                                 write8(w, 0)
19199                         }
19200                 }
19201                 {
19202                         buf := w
19203                         w := ow
19204                         if len((buf.Bytes())) > math.MaxUint16 {
19205                                 chk(ErrTooLong)
19206                         }
19207                         {
19208                                 x := uint16(len((buf.Bytes())))
19209                                 write16(w, uint16(x))
19210                         }
19211                         {
19212                                 _, err := w.Write((buf.Bytes())[:])
19213                                 chk(err)
19214                         }
19215                 }
19216         }
19217 }
19218
19219 func (obj *NodeDef) Deserialize(r io.Reader) {
19220         if err := pcall(func() {
19221                 ((*(*(struct {
19222                         Param0 Content
19223
19224                         Name   string
19225                         Groups []Group
19226
19227                         P1Type   Param1Type
19228                         P2Type   Param2Type
19229                         DrawType DrawType
19230
19231                         Mesh  string
19232                         Scale float32
19233                         //mt:const uint8(6)
19234                         Tiles        [6]TileDef
19235                         OverlayTiles [6]TileDef
19236                         //mt:const uint8(6)
19237                         SpecialTiles [6]TileDef
19238
19239                         Color   color.NRGBA
19240                         Palette Texture
19241
19242                         Waving       WaveType
19243                         ConnectSides uint8
19244                         ConnectTo    []Content
19245                         InsideTint   color.NRGBA
19246                         Level        uint8 // Must be < 128.
19247
19248                         Translucent bool // Sunlight is scattered and becomes normal light.
19249                         Transparent bool // Sunlight isn't scattered.
19250                         LightSrc    uint8
19251
19252                         GndContent   bool
19253                         Collides     bool
19254                         Pointable    bool
19255                         Diggable     bool
19256                         Climbable    bool
19257                         Replaceable  bool
19258                         OnRightClick bool
19259
19260                         DmgPerSec int32
19261
19262                         LiquidType   LiquidType
19263                         FlowingAlt   string
19264                         SrcAlt       string
19265                         Viscosity    uint8 // 0-7
19266                         LiqRenewable bool
19267                         FlowRange    uint8
19268                         DrownDmg     uint8
19269                         Floodable    bool
19270
19271                         DrawBox, ColBox, SelBox NodeBox
19272
19273                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19274
19275                         LegacyFaceDir bool
19276                         LegacyMounted bool
19277
19278                         DigPredict string
19279
19280                         MaxLvl uint8
19281
19282                         AlphaUse
19283
19284                         MoveResistance uint8
19285
19286                         LiquidMovePhysics bool
19287                 }))(obj)).Param0).Deserialize(r)
19288         }); err != nil {
19289                 if err == io.EOF {
19290                         chk(io.EOF)
19291                 }
19292                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
19293         }
19294         {
19295                 var n uint16
19296                 {
19297                         p := &n
19298                         *p = read16(r)
19299                 }
19300                 r := &io.LimitedReader{R: r, N: int64(n)}
19301                 {
19302                         var local246 uint8
19303                         local247 := uint8(13)
19304                         {
19305                                 p := &local246
19306                                 *p = read8(r)
19307                         }
19308                         if local246 != local247 {
19309                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local246))
19310                         }
19311                 }
19312                 var local248 []uint8
19313                 var local249 uint16
19314                 {
19315                         p := &local249
19316                         *p = read16(r)
19317                 }
19318                 (local248) = make([]uint8, local249)
19319                 {
19320                         _, err := io.ReadFull(r, (local248)[:])
19321                         chk(err)
19322                 }
19323                 ((*(*(struct {
19324                         Param0 Content
19325
19326                         Name   string
19327                         Groups []Group
19328
19329                         P1Type   Param1Type
19330                         P2Type   Param2Type
19331                         DrawType DrawType
19332
19333                         Mesh  string
19334                         Scale float32
19335                         //mt:const uint8(6)
19336                         Tiles        [6]TileDef
19337                         OverlayTiles [6]TileDef
19338                         //mt:const uint8(6)
19339                         SpecialTiles [6]TileDef
19340
19341                         Color   color.NRGBA
19342                         Palette Texture
19343
19344                         Waving       WaveType
19345                         ConnectSides uint8
19346                         ConnectTo    []Content
19347                         InsideTint   color.NRGBA
19348                         Level        uint8 // Must be < 128.
19349
19350                         Translucent bool // Sunlight is scattered and becomes normal light.
19351                         Transparent bool // Sunlight isn't scattered.
19352                         LightSrc    uint8
19353
19354                         GndContent   bool
19355                         Collides     bool
19356                         Pointable    bool
19357                         Diggable     bool
19358                         Climbable    bool
19359                         Replaceable  bool
19360                         OnRightClick bool
19361
19362                         DmgPerSec int32
19363
19364                         LiquidType   LiquidType
19365                         FlowingAlt   string
19366                         SrcAlt       string
19367                         Viscosity    uint8 // 0-7
19368                         LiqRenewable bool
19369                         FlowRange    uint8
19370                         DrownDmg     uint8
19371                         Floodable    bool
19372
19373                         DrawBox, ColBox, SelBox NodeBox
19374
19375                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19376
19377                         LegacyFaceDir bool
19378                         LegacyMounted bool
19379
19380                         DigPredict string
19381
19382                         MaxLvl uint8
19383
19384                         AlphaUse
19385
19386                         MoveResistance uint8
19387
19388                         LiquidMovePhysics bool
19389                 }))(obj)).Name) = string(local248)
19390                 var local250 uint16
19391                 {
19392                         p := &local250
19393                         *p = read16(r)
19394                 }
19395                 ((*(*(struct {
19396                         Param0 Content
19397
19398                         Name   string
19399                         Groups []Group
19400
19401                         P1Type   Param1Type
19402                         P2Type   Param2Type
19403                         DrawType DrawType
19404
19405                         Mesh  string
19406                         Scale float32
19407                         //mt:const uint8(6)
19408                         Tiles        [6]TileDef
19409                         OverlayTiles [6]TileDef
19410                         //mt:const uint8(6)
19411                         SpecialTiles [6]TileDef
19412
19413                         Color   color.NRGBA
19414                         Palette Texture
19415
19416                         Waving       WaveType
19417                         ConnectSides uint8
19418                         ConnectTo    []Content
19419                         InsideTint   color.NRGBA
19420                         Level        uint8 // Must be < 128.
19421
19422                         Translucent bool // Sunlight is scattered and becomes normal light.
19423                         Transparent bool // Sunlight isn't scattered.
19424                         LightSrc    uint8
19425
19426                         GndContent   bool
19427                         Collides     bool
19428                         Pointable    bool
19429                         Diggable     bool
19430                         Climbable    bool
19431                         Replaceable  bool
19432                         OnRightClick bool
19433
19434                         DmgPerSec int32
19435
19436                         LiquidType   LiquidType
19437                         FlowingAlt   string
19438                         SrcAlt       string
19439                         Viscosity    uint8 // 0-7
19440                         LiqRenewable bool
19441                         FlowRange    uint8
19442                         DrownDmg     uint8
19443                         Floodable    bool
19444
19445                         DrawBox, ColBox, SelBox NodeBox
19446
19447                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19448
19449                         LegacyFaceDir bool
19450                         LegacyMounted bool
19451
19452                         DigPredict string
19453
19454                         MaxLvl uint8
19455
19456                         AlphaUse
19457
19458                         MoveResistance uint8
19459
19460                         LiquidMovePhysics bool
19461                 }))(obj)).Groups) = make([]Group, local250)
19462                 for local251 := range (*(*(struct {
19463                         Param0 Content
19464
19465                         Name   string
19466                         Groups []Group
19467
19468                         P1Type   Param1Type
19469                         P2Type   Param2Type
19470                         DrawType DrawType
19471
19472                         Mesh  string
19473                         Scale float32
19474                         //mt:const uint8(6)
19475                         Tiles        [6]TileDef
19476                         OverlayTiles [6]TileDef
19477                         //mt:const uint8(6)
19478                         SpecialTiles [6]TileDef
19479
19480                         Color   color.NRGBA
19481                         Palette Texture
19482
19483                         Waving       WaveType
19484                         ConnectSides uint8
19485                         ConnectTo    []Content
19486                         InsideTint   color.NRGBA
19487                         Level        uint8 // Must be < 128.
19488
19489                         Translucent bool // Sunlight is scattered and becomes normal light.
19490                         Transparent bool // Sunlight isn't scattered.
19491                         LightSrc    uint8
19492
19493                         GndContent   bool
19494                         Collides     bool
19495                         Pointable    bool
19496                         Diggable     bool
19497                         Climbable    bool
19498                         Replaceable  bool
19499                         OnRightClick bool
19500
19501                         DmgPerSec int32
19502
19503                         LiquidType   LiquidType
19504                         FlowingAlt   string
19505                         SrcAlt       string
19506                         Viscosity    uint8 // 0-7
19507                         LiqRenewable bool
19508                         FlowRange    uint8
19509                         DrownDmg     uint8
19510                         Floodable    bool
19511
19512                         DrawBox, ColBox, SelBox NodeBox
19513
19514                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19515
19516                         LegacyFaceDir bool
19517                         LegacyMounted bool
19518
19519                         DigPredict string
19520
19521                         MaxLvl uint8
19522
19523                         AlphaUse
19524
19525                         MoveResistance uint8
19526
19527                         LiquidMovePhysics bool
19528                 }))(obj)).Groups {
19529                         if err := pcall(func() {
19530                                 (((*(*(struct {
19531                                         Param0 Content
19532
19533                                         Name   string
19534                                         Groups []Group
19535
19536                                         P1Type   Param1Type
19537                                         P2Type   Param2Type
19538                                         DrawType DrawType
19539
19540                                         Mesh  string
19541                                         Scale float32
19542                                         //mt:const uint8(6)
19543                                         Tiles        [6]TileDef
19544                                         OverlayTiles [6]TileDef
19545                                         //mt:const uint8(6)
19546                                         SpecialTiles [6]TileDef
19547
19548                                         Color   color.NRGBA
19549                                         Palette Texture
19550
19551                                         Waving       WaveType
19552                                         ConnectSides uint8
19553                                         ConnectTo    []Content
19554                                         InsideTint   color.NRGBA
19555                                         Level        uint8 // Must be < 128.
19556
19557                                         Translucent bool // Sunlight is scattered and becomes normal light.
19558                                         Transparent bool // Sunlight isn't scattered.
19559                                         LightSrc    uint8
19560
19561                                         GndContent   bool
19562                                         Collides     bool
19563                                         Pointable    bool
19564                                         Diggable     bool
19565                                         Climbable    bool
19566                                         Replaceable  bool
19567                                         OnRightClick bool
19568
19569                                         DmgPerSec int32
19570
19571                                         LiquidType   LiquidType
19572                                         FlowingAlt   string
19573                                         SrcAlt       string
19574                                         Viscosity    uint8 // 0-7
19575                                         LiqRenewable bool
19576                                         FlowRange    uint8
19577                                         DrownDmg     uint8
19578                                         Floodable    bool
19579
19580                                         DrawBox, ColBox, SelBox NodeBox
19581
19582                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19583
19584                                         LegacyFaceDir bool
19585                                         LegacyMounted bool
19586
19587                                         DigPredict string
19588
19589                                         MaxLvl uint8
19590
19591                                         AlphaUse
19592
19593                                         MoveResistance uint8
19594
19595                                         LiquidMovePhysics bool
19596                                 }))(obj)).Groups)[local251]).Deserialize(r)
19597                         }); err != nil {
19598                                 if err == io.EOF {
19599                                         chk(io.EOF)
19600                                 }
19601                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
19602                         }
19603                 }
19604                 if err := pcall(func() {
19605                         ((*(*(struct {
19606                                 Param0 Content
19607
19608                                 Name   string
19609                                 Groups []Group
19610
19611                                 P1Type   Param1Type
19612                                 P2Type   Param2Type
19613                                 DrawType DrawType
19614
19615                                 Mesh  string
19616                                 Scale float32
19617                                 //mt:const uint8(6)
19618                                 Tiles        [6]TileDef
19619                                 OverlayTiles [6]TileDef
19620                                 //mt:const uint8(6)
19621                                 SpecialTiles [6]TileDef
19622
19623                                 Color   color.NRGBA
19624                                 Palette Texture
19625
19626                                 Waving       WaveType
19627                                 ConnectSides uint8
19628                                 ConnectTo    []Content
19629                                 InsideTint   color.NRGBA
19630                                 Level        uint8 // Must be < 128.
19631
19632                                 Translucent bool // Sunlight is scattered and becomes normal light.
19633                                 Transparent bool // Sunlight isn't scattered.
19634                                 LightSrc    uint8
19635
19636                                 GndContent   bool
19637                                 Collides     bool
19638                                 Pointable    bool
19639                                 Diggable     bool
19640                                 Climbable    bool
19641                                 Replaceable  bool
19642                                 OnRightClick bool
19643
19644                                 DmgPerSec int32
19645
19646                                 LiquidType   LiquidType
19647                                 FlowingAlt   string
19648                                 SrcAlt       string
19649                                 Viscosity    uint8 // 0-7
19650                                 LiqRenewable bool
19651                                 FlowRange    uint8
19652                                 DrownDmg     uint8
19653                                 Floodable    bool
19654
19655                                 DrawBox, ColBox, SelBox NodeBox
19656
19657                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19658
19659                                 LegacyFaceDir bool
19660                                 LegacyMounted bool
19661
19662                                 DigPredict string
19663
19664                                 MaxLvl uint8
19665
19666                                 AlphaUse
19667
19668                                 MoveResistance uint8
19669
19670                                 LiquidMovePhysics bool
19671                         }))(obj)).P1Type).Deserialize(r)
19672                 }); err != nil {
19673                         if err == io.EOF {
19674                                 chk(io.EOF)
19675                         }
19676                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param1Type", err))
19677                 }
19678                 if err := pcall(func() {
19679                         ((*(*(struct {
19680                                 Param0 Content
19681
19682                                 Name   string
19683                                 Groups []Group
19684
19685                                 P1Type   Param1Type
19686                                 P2Type   Param2Type
19687                                 DrawType DrawType
19688
19689                                 Mesh  string
19690                                 Scale float32
19691                                 //mt:const uint8(6)
19692                                 Tiles        [6]TileDef
19693                                 OverlayTiles [6]TileDef
19694                                 //mt:const uint8(6)
19695                                 SpecialTiles [6]TileDef
19696
19697                                 Color   color.NRGBA
19698                                 Palette Texture
19699
19700                                 Waving       WaveType
19701                                 ConnectSides uint8
19702                                 ConnectTo    []Content
19703                                 InsideTint   color.NRGBA
19704                                 Level        uint8 // Must be < 128.
19705
19706                                 Translucent bool // Sunlight is scattered and becomes normal light.
19707                                 Transparent bool // Sunlight isn't scattered.
19708                                 LightSrc    uint8
19709
19710                                 GndContent   bool
19711                                 Collides     bool
19712                                 Pointable    bool
19713                                 Diggable     bool
19714                                 Climbable    bool
19715                                 Replaceable  bool
19716                                 OnRightClick bool
19717
19718                                 DmgPerSec int32
19719
19720                                 LiquidType   LiquidType
19721                                 FlowingAlt   string
19722                                 SrcAlt       string
19723                                 Viscosity    uint8 // 0-7
19724                                 LiqRenewable bool
19725                                 FlowRange    uint8
19726                                 DrownDmg     uint8
19727                                 Floodable    bool
19728
19729                                 DrawBox, ColBox, SelBox NodeBox
19730
19731                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19732
19733                                 LegacyFaceDir bool
19734                                 LegacyMounted bool
19735
19736                                 DigPredict string
19737
19738                                 MaxLvl uint8
19739
19740                                 AlphaUse
19741
19742                                 MoveResistance uint8
19743
19744                                 LiquidMovePhysics bool
19745                         }))(obj)).P2Type).Deserialize(r)
19746                 }); err != nil {
19747                         if err == io.EOF {
19748                                 chk(io.EOF)
19749                         }
19750                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param2Type", err))
19751                 }
19752                 if err := pcall(func() {
19753                         ((*(*(struct {
19754                                 Param0 Content
19755
19756                                 Name   string
19757                                 Groups []Group
19758
19759                                 P1Type   Param1Type
19760                                 P2Type   Param2Type
19761                                 DrawType DrawType
19762
19763                                 Mesh  string
19764                                 Scale float32
19765                                 //mt:const uint8(6)
19766                                 Tiles        [6]TileDef
19767                                 OverlayTiles [6]TileDef
19768                                 //mt:const uint8(6)
19769                                 SpecialTiles [6]TileDef
19770
19771                                 Color   color.NRGBA
19772                                 Palette Texture
19773
19774                                 Waving       WaveType
19775                                 ConnectSides uint8
19776                                 ConnectTo    []Content
19777                                 InsideTint   color.NRGBA
19778                                 Level        uint8 // Must be < 128.
19779
19780                                 Translucent bool // Sunlight is scattered and becomes normal light.
19781                                 Transparent bool // Sunlight isn't scattered.
19782                                 LightSrc    uint8
19783
19784                                 GndContent   bool
19785                                 Collides     bool
19786                                 Pointable    bool
19787                                 Diggable     bool
19788                                 Climbable    bool
19789                                 Replaceable  bool
19790                                 OnRightClick bool
19791
19792                                 DmgPerSec int32
19793
19794                                 LiquidType   LiquidType
19795                                 FlowingAlt   string
19796                                 SrcAlt       string
19797                                 Viscosity    uint8 // 0-7
19798                                 LiqRenewable bool
19799                                 FlowRange    uint8
19800                                 DrownDmg     uint8
19801                                 Floodable    bool
19802
19803                                 DrawBox, ColBox, SelBox NodeBox
19804
19805                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19806
19807                                 LegacyFaceDir bool
19808                                 LegacyMounted bool
19809
19810                                 DigPredict string
19811
19812                                 MaxLvl uint8
19813
19814                                 AlphaUse
19815
19816                                 MoveResistance uint8
19817
19818                                 LiquidMovePhysics bool
19819                         }))(obj)).DrawType).Deserialize(r)
19820                 }); err != nil {
19821                         if err == io.EOF {
19822                                 chk(io.EOF)
19823                         }
19824                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DrawType", err))
19825                 }
19826                 var local252 []uint8
19827                 var local253 uint16
19828                 {
19829                         p := &local253
19830                         *p = read16(r)
19831                 }
19832                 (local252) = make([]uint8, local253)
19833                 {
19834                         _, err := io.ReadFull(r, (local252)[:])
19835                         chk(err)
19836                 }
19837                 ((*(*(struct {
19838                         Param0 Content
19839
19840                         Name   string
19841                         Groups []Group
19842
19843                         P1Type   Param1Type
19844                         P2Type   Param2Type
19845                         DrawType DrawType
19846
19847                         Mesh  string
19848                         Scale float32
19849                         //mt:const uint8(6)
19850                         Tiles        [6]TileDef
19851                         OverlayTiles [6]TileDef
19852                         //mt:const uint8(6)
19853                         SpecialTiles [6]TileDef
19854
19855                         Color   color.NRGBA
19856                         Palette Texture
19857
19858                         Waving       WaveType
19859                         ConnectSides uint8
19860                         ConnectTo    []Content
19861                         InsideTint   color.NRGBA
19862                         Level        uint8 // Must be < 128.
19863
19864                         Translucent bool // Sunlight is scattered and becomes normal light.
19865                         Transparent bool // Sunlight isn't scattered.
19866                         LightSrc    uint8
19867
19868                         GndContent   bool
19869                         Collides     bool
19870                         Pointable    bool
19871                         Diggable     bool
19872                         Climbable    bool
19873                         Replaceable  bool
19874                         OnRightClick bool
19875
19876                         DmgPerSec int32
19877
19878                         LiquidType   LiquidType
19879                         FlowingAlt   string
19880                         SrcAlt       string
19881                         Viscosity    uint8 // 0-7
19882                         LiqRenewable bool
19883                         FlowRange    uint8
19884                         DrownDmg     uint8
19885                         Floodable    bool
19886
19887                         DrawBox, ColBox, SelBox NodeBox
19888
19889                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19890
19891                         LegacyFaceDir bool
19892                         LegacyMounted bool
19893
19894                         DigPredict string
19895
19896                         MaxLvl uint8
19897
19898                         AlphaUse
19899
19900                         MoveResistance uint8
19901
19902                         LiquidMovePhysics bool
19903                 }))(obj)).Mesh) = string(local252)
19904                 {
19905                         p := &(*(*(struct {
19906                                 Param0 Content
19907
19908                                 Name   string
19909                                 Groups []Group
19910
19911                                 P1Type   Param1Type
19912                                 P2Type   Param2Type
19913                                 DrawType DrawType
19914
19915                                 Mesh  string
19916                                 Scale float32
19917                                 //mt:const uint8(6)
19918                                 Tiles        [6]TileDef
19919                                 OverlayTiles [6]TileDef
19920                                 //mt:const uint8(6)
19921                                 SpecialTiles [6]TileDef
19922
19923                                 Color   color.NRGBA
19924                                 Palette Texture
19925
19926                                 Waving       WaveType
19927                                 ConnectSides uint8
19928                                 ConnectTo    []Content
19929                                 InsideTint   color.NRGBA
19930                                 Level        uint8 // Must be < 128.
19931
19932                                 Translucent bool // Sunlight is scattered and becomes normal light.
19933                                 Transparent bool // Sunlight isn't scattered.
19934                                 LightSrc    uint8
19935
19936                                 GndContent   bool
19937                                 Collides     bool
19938                                 Pointable    bool
19939                                 Diggable     bool
19940                                 Climbable    bool
19941                                 Replaceable  bool
19942                                 OnRightClick bool
19943
19944                                 DmgPerSec int32
19945
19946                                 LiquidType   LiquidType
19947                                 FlowingAlt   string
19948                                 SrcAlt       string
19949                                 Viscosity    uint8 // 0-7
19950                                 LiqRenewable bool
19951                                 FlowRange    uint8
19952                                 DrownDmg     uint8
19953                                 Floodable    bool
19954
19955                                 DrawBox, ColBox, SelBox NodeBox
19956
19957                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19958
19959                                 LegacyFaceDir bool
19960                                 LegacyMounted bool
19961
19962                                 DigPredict string
19963
19964                                 MaxLvl uint8
19965
19966                                 AlphaUse
19967
19968                                 MoveResistance uint8
19969
19970                                 LiquidMovePhysics bool
19971                         }))(obj)).Scale
19972                         *p = math.Float32frombits(read32(r))
19973                 }
19974                 {
19975                         var local254 uint8
19976                         local255 := uint8(6)
19977                         {
19978                                 p := &local254
19979                                 *p = read8(r)
19980                         }
19981                         if local254 != local255 {
19982                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local254))
19983                         }
19984                 }
19985                 for local256 := range (*(*(struct {
19986                         Param0 Content
19987
19988                         Name   string
19989                         Groups []Group
19990
19991                         P1Type   Param1Type
19992                         P2Type   Param2Type
19993                         DrawType DrawType
19994
19995                         Mesh  string
19996                         Scale float32
19997                         //mt:const uint8(6)
19998                         Tiles        [6]TileDef
19999                         OverlayTiles [6]TileDef
20000                         //mt:const uint8(6)
20001                         SpecialTiles [6]TileDef
20002
20003                         Color   color.NRGBA
20004                         Palette Texture
20005
20006                         Waving       WaveType
20007                         ConnectSides uint8
20008                         ConnectTo    []Content
20009                         InsideTint   color.NRGBA
20010                         Level        uint8 // Must be < 128.
20011
20012                         Translucent bool // Sunlight is scattered and becomes normal light.
20013                         Transparent bool // Sunlight isn't scattered.
20014                         LightSrc    uint8
20015
20016                         GndContent   bool
20017                         Collides     bool
20018                         Pointable    bool
20019                         Diggable     bool
20020                         Climbable    bool
20021                         Replaceable  bool
20022                         OnRightClick bool
20023
20024                         DmgPerSec int32
20025
20026                         LiquidType   LiquidType
20027                         FlowingAlt   string
20028                         SrcAlt       string
20029                         Viscosity    uint8 // 0-7
20030                         LiqRenewable bool
20031                         FlowRange    uint8
20032                         DrownDmg     uint8
20033                         Floodable    bool
20034
20035                         DrawBox, ColBox, SelBox NodeBox
20036
20037                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20038
20039                         LegacyFaceDir bool
20040                         LegacyMounted bool
20041
20042                         DigPredict string
20043
20044                         MaxLvl uint8
20045
20046                         AlphaUse
20047
20048                         MoveResistance uint8
20049
20050                         LiquidMovePhysics bool
20051                 }))(obj)).Tiles {
20052                         if err := pcall(func() {
20053                                 (((*(*(struct {
20054                                         Param0 Content
20055
20056                                         Name   string
20057                                         Groups []Group
20058
20059                                         P1Type   Param1Type
20060                                         P2Type   Param2Type
20061                                         DrawType DrawType
20062
20063                                         Mesh  string
20064                                         Scale float32
20065                                         //mt:const uint8(6)
20066                                         Tiles        [6]TileDef
20067                                         OverlayTiles [6]TileDef
20068                                         //mt:const uint8(6)
20069                                         SpecialTiles [6]TileDef
20070
20071                                         Color   color.NRGBA
20072                                         Palette Texture
20073
20074                                         Waving       WaveType
20075                                         ConnectSides uint8
20076                                         ConnectTo    []Content
20077                                         InsideTint   color.NRGBA
20078                                         Level        uint8 // Must be < 128.
20079
20080                                         Translucent bool // Sunlight is scattered and becomes normal light.
20081                                         Transparent bool // Sunlight isn't scattered.
20082                                         LightSrc    uint8
20083
20084                                         GndContent   bool
20085                                         Collides     bool
20086                                         Pointable    bool
20087                                         Diggable     bool
20088                                         Climbable    bool
20089                                         Replaceable  bool
20090                                         OnRightClick bool
20091
20092                                         DmgPerSec int32
20093
20094                                         LiquidType   LiquidType
20095                                         FlowingAlt   string
20096                                         SrcAlt       string
20097                                         Viscosity    uint8 // 0-7
20098                                         LiqRenewable bool
20099                                         FlowRange    uint8
20100                                         DrownDmg     uint8
20101                                         Floodable    bool
20102
20103                                         DrawBox, ColBox, SelBox NodeBox
20104
20105                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20106
20107                                         LegacyFaceDir bool
20108                                         LegacyMounted bool
20109
20110                                         DigPredict string
20111
20112                                         MaxLvl uint8
20113
20114                                         AlphaUse
20115
20116                                         MoveResistance uint8
20117
20118                                         LiquidMovePhysics bool
20119                                 }))(obj)).Tiles)[local256]).Deserialize(r)
20120                         }); err != nil {
20121                                 if err == io.EOF {
20122                                         chk(io.EOF)
20123                                 }
20124                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20125                         }
20126                 }
20127                 for local257 := range (*(*(struct {
20128                         Param0 Content
20129
20130                         Name   string
20131                         Groups []Group
20132
20133                         P1Type   Param1Type
20134                         P2Type   Param2Type
20135                         DrawType DrawType
20136
20137                         Mesh  string
20138                         Scale float32
20139                         //mt:const uint8(6)
20140                         Tiles        [6]TileDef
20141                         OverlayTiles [6]TileDef
20142                         //mt:const uint8(6)
20143                         SpecialTiles [6]TileDef
20144
20145                         Color   color.NRGBA
20146                         Palette Texture
20147
20148                         Waving       WaveType
20149                         ConnectSides uint8
20150                         ConnectTo    []Content
20151                         InsideTint   color.NRGBA
20152                         Level        uint8 // Must be < 128.
20153
20154                         Translucent bool // Sunlight is scattered and becomes normal light.
20155                         Transparent bool // Sunlight isn't scattered.
20156                         LightSrc    uint8
20157
20158                         GndContent   bool
20159                         Collides     bool
20160                         Pointable    bool
20161                         Diggable     bool
20162                         Climbable    bool
20163                         Replaceable  bool
20164                         OnRightClick bool
20165
20166                         DmgPerSec int32
20167
20168                         LiquidType   LiquidType
20169                         FlowingAlt   string
20170                         SrcAlt       string
20171                         Viscosity    uint8 // 0-7
20172                         LiqRenewable bool
20173                         FlowRange    uint8
20174                         DrownDmg     uint8
20175                         Floodable    bool
20176
20177                         DrawBox, ColBox, SelBox NodeBox
20178
20179                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20180
20181                         LegacyFaceDir bool
20182                         LegacyMounted bool
20183
20184                         DigPredict string
20185
20186                         MaxLvl uint8
20187
20188                         AlphaUse
20189
20190                         MoveResistance uint8
20191
20192                         LiquidMovePhysics bool
20193                 }))(obj)).OverlayTiles {
20194                         if err := pcall(func() {
20195                                 (((*(*(struct {
20196                                         Param0 Content
20197
20198                                         Name   string
20199                                         Groups []Group
20200
20201                                         P1Type   Param1Type
20202                                         P2Type   Param2Type
20203                                         DrawType DrawType
20204
20205                                         Mesh  string
20206                                         Scale float32
20207                                         //mt:const uint8(6)
20208                                         Tiles        [6]TileDef
20209                                         OverlayTiles [6]TileDef
20210                                         //mt:const uint8(6)
20211                                         SpecialTiles [6]TileDef
20212
20213                                         Color   color.NRGBA
20214                                         Palette Texture
20215
20216                                         Waving       WaveType
20217                                         ConnectSides uint8
20218                                         ConnectTo    []Content
20219                                         InsideTint   color.NRGBA
20220                                         Level        uint8 // Must be < 128.
20221
20222                                         Translucent bool // Sunlight is scattered and becomes normal light.
20223                                         Transparent bool // Sunlight isn't scattered.
20224                                         LightSrc    uint8
20225
20226                                         GndContent   bool
20227                                         Collides     bool
20228                                         Pointable    bool
20229                                         Diggable     bool
20230                                         Climbable    bool
20231                                         Replaceable  bool
20232                                         OnRightClick bool
20233
20234                                         DmgPerSec int32
20235
20236                                         LiquidType   LiquidType
20237                                         FlowingAlt   string
20238                                         SrcAlt       string
20239                                         Viscosity    uint8 // 0-7
20240                                         LiqRenewable bool
20241                                         FlowRange    uint8
20242                                         DrownDmg     uint8
20243                                         Floodable    bool
20244
20245                                         DrawBox, ColBox, SelBox NodeBox
20246
20247                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20248
20249                                         LegacyFaceDir bool
20250                                         LegacyMounted bool
20251
20252                                         DigPredict string
20253
20254                                         MaxLvl uint8
20255
20256                                         AlphaUse
20257
20258                                         MoveResistance uint8
20259
20260                                         LiquidMovePhysics bool
20261                                 }))(obj)).OverlayTiles)[local257]).Deserialize(r)
20262                         }); err != nil {
20263                                 if err == io.EOF {
20264                                         chk(io.EOF)
20265                                 }
20266                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20267                         }
20268                 }
20269                 {
20270                         var local258 uint8
20271                         local259 := uint8(6)
20272                         {
20273                                 p := &local258
20274                                 *p = read8(r)
20275                         }
20276                         if local258 != local259 {
20277                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local258))
20278                         }
20279                 }
20280                 for local260 := range (*(*(struct {
20281                         Param0 Content
20282
20283                         Name   string
20284                         Groups []Group
20285
20286                         P1Type   Param1Type
20287                         P2Type   Param2Type
20288                         DrawType DrawType
20289
20290                         Mesh  string
20291                         Scale float32
20292                         //mt:const uint8(6)
20293                         Tiles        [6]TileDef
20294                         OverlayTiles [6]TileDef
20295                         //mt:const uint8(6)
20296                         SpecialTiles [6]TileDef
20297
20298                         Color   color.NRGBA
20299                         Palette Texture
20300
20301                         Waving       WaveType
20302                         ConnectSides uint8
20303                         ConnectTo    []Content
20304                         InsideTint   color.NRGBA
20305                         Level        uint8 // Must be < 128.
20306
20307                         Translucent bool // Sunlight is scattered and becomes normal light.
20308                         Transparent bool // Sunlight isn't scattered.
20309                         LightSrc    uint8
20310
20311                         GndContent   bool
20312                         Collides     bool
20313                         Pointable    bool
20314                         Diggable     bool
20315                         Climbable    bool
20316                         Replaceable  bool
20317                         OnRightClick bool
20318
20319                         DmgPerSec int32
20320
20321                         LiquidType   LiquidType
20322                         FlowingAlt   string
20323                         SrcAlt       string
20324                         Viscosity    uint8 // 0-7
20325                         LiqRenewable bool
20326                         FlowRange    uint8
20327                         DrownDmg     uint8
20328                         Floodable    bool
20329
20330                         DrawBox, ColBox, SelBox NodeBox
20331
20332                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20333
20334                         LegacyFaceDir bool
20335                         LegacyMounted bool
20336
20337                         DigPredict string
20338
20339                         MaxLvl uint8
20340
20341                         AlphaUse
20342
20343                         MoveResistance uint8
20344
20345                         LiquidMovePhysics bool
20346                 }))(obj)).SpecialTiles {
20347                         if err := pcall(func() {
20348                                 (((*(*(struct {
20349                                         Param0 Content
20350
20351                                         Name   string
20352                                         Groups []Group
20353
20354                                         P1Type   Param1Type
20355                                         P2Type   Param2Type
20356                                         DrawType DrawType
20357
20358                                         Mesh  string
20359                                         Scale float32
20360                                         //mt:const uint8(6)
20361                                         Tiles        [6]TileDef
20362                                         OverlayTiles [6]TileDef
20363                                         //mt:const uint8(6)
20364                                         SpecialTiles [6]TileDef
20365
20366                                         Color   color.NRGBA
20367                                         Palette Texture
20368
20369                                         Waving       WaveType
20370                                         ConnectSides uint8
20371                                         ConnectTo    []Content
20372                                         InsideTint   color.NRGBA
20373                                         Level        uint8 // Must be < 128.
20374
20375                                         Translucent bool // Sunlight is scattered and becomes normal light.
20376                                         Transparent bool // Sunlight isn't scattered.
20377                                         LightSrc    uint8
20378
20379                                         GndContent   bool
20380                                         Collides     bool
20381                                         Pointable    bool
20382                                         Diggable     bool
20383                                         Climbable    bool
20384                                         Replaceable  bool
20385                                         OnRightClick bool
20386
20387                                         DmgPerSec int32
20388
20389                                         LiquidType   LiquidType
20390                                         FlowingAlt   string
20391                                         SrcAlt       string
20392                                         Viscosity    uint8 // 0-7
20393                                         LiqRenewable bool
20394                                         FlowRange    uint8
20395                                         DrownDmg     uint8
20396                                         Floodable    bool
20397
20398                                         DrawBox, ColBox, SelBox NodeBox
20399
20400                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20401
20402                                         LegacyFaceDir bool
20403                                         LegacyMounted bool
20404
20405                                         DigPredict string
20406
20407                                         MaxLvl uint8
20408
20409                                         AlphaUse
20410
20411                                         MoveResistance uint8
20412
20413                                         LiquidMovePhysics bool
20414                                 }))(obj)).SpecialTiles)[local260]).Deserialize(r)
20415                         }); err != nil {
20416                                 if err == io.EOF {
20417                                         chk(io.EOF)
20418                                 }
20419                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20420                         }
20421                 }
20422                 {
20423                         p := &(*(*(struct {
20424                                 Param0 Content
20425
20426                                 Name   string
20427                                 Groups []Group
20428
20429                                 P1Type   Param1Type
20430                                 P2Type   Param2Type
20431                                 DrawType DrawType
20432
20433                                 Mesh  string
20434                                 Scale float32
20435                                 //mt:const uint8(6)
20436                                 Tiles        [6]TileDef
20437                                 OverlayTiles [6]TileDef
20438                                 //mt:const uint8(6)
20439                                 SpecialTiles [6]TileDef
20440
20441                                 Color   color.NRGBA
20442                                 Palette Texture
20443
20444                                 Waving       WaveType
20445                                 ConnectSides uint8
20446                                 ConnectTo    []Content
20447                                 InsideTint   color.NRGBA
20448                                 Level        uint8 // Must be < 128.
20449
20450                                 Translucent bool // Sunlight is scattered and becomes normal light.
20451                                 Transparent bool // Sunlight isn't scattered.
20452                                 LightSrc    uint8
20453
20454                                 GndContent   bool
20455                                 Collides     bool
20456                                 Pointable    bool
20457                                 Diggable     bool
20458                                 Climbable    bool
20459                                 Replaceable  bool
20460                                 OnRightClick bool
20461
20462                                 DmgPerSec int32
20463
20464                                 LiquidType   LiquidType
20465                                 FlowingAlt   string
20466                                 SrcAlt       string
20467                                 Viscosity    uint8 // 0-7
20468                                 LiqRenewable bool
20469                                 FlowRange    uint8
20470                                 DrownDmg     uint8
20471                                 Floodable    bool
20472
20473                                 DrawBox, ColBox, SelBox NodeBox
20474
20475                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20476
20477                                 LegacyFaceDir bool
20478                                 LegacyMounted bool
20479
20480                                 DigPredict string
20481
20482                                 MaxLvl uint8
20483
20484                                 AlphaUse
20485
20486                                 MoveResistance uint8
20487
20488                                 LiquidMovePhysics bool
20489                         }))(obj)).Color
20490                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20491                 }
20492                 if err := pcall(func() {
20493                         ((*(*(struct {
20494                                 Param0 Content
20495
20496                                 Name   string
20497                                 Groups []Group
20498
20499                                 P1Type   Param1Type
20500                                 P2Type   Param2Type
20501                                 DrawType DrawType
20502
20503                                 Mesh  string
20504                                 Scale float32
20505                                 //mt:const uint8(6)
20506                                 Tiles        [6]TileDef
20507                                 OverlayTiles [6]TileDef
20508                                 //mt:const uint8(6)
20509                                 SpecialTiles [6]TileDef
20510
20511                                 Color   color.NRGBA
20512                                 Palette Texture
20513
20514                                 Waving       WaveType
20515                                 ConnectSides uint8
20516                                 ConnectTo    []Content
20517                                 InsideTint   color.NRGBA
20518                                 Level        uint8 // Must be < 128.
20519
20520                                 Translucent bool // Sunlight is scattered and becomes normal light.
20521                                 Transparent bool // Sunlight isn't scattered.
20522                                 LightSrc    uint8
20523
20524                                 GndContent   bool
20525                                 Collides     bool
20526                                 Pointable    bool
20527                                 Diggable     bool
20528                                 Climbable    bool
20529                                 Replaceable  bool
20530                                 OnRightClick bool
20531
20532                                 DmgPerSec int32
20533
20534                                 LiquidType   LiquidType
20535                                 FlowingAlt   string
20536                                 SrcAlt       string
20537                                 Viscosity    uint8 // 0-7
20538                                 LiqRenewable bool
20539                                 FlowRange    uint8
20540                                 DrownDmg     uint8
20541                                 Floodable    bool
20542
20543                                 DrawBox, ColBox, SelBox NodeBox
20544
20545                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20546
20547                                 LegacyFaceDir bool
20548                                 LegacyMounted bool
20549
20550                                 DigPredict string
20551
20552                                 MaxLvl uint8
20553
20554                                 AlphaUse
20555
20556                                 MoveResistance uint8
20557
20558                                 LiquidMovePhysics bool
20559                         }))(obj)).Palette).Deserialize(r)
20560                 }); err != nil {
20561                         if err == io.EOF {
20562                                 chk(io.EOF)
20563                         }
20564                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
20565                 }
20566                 if err := pcall(func() {
20567                         ((*(*(struct {
20568                                 Param0 Content
20569
20570                                 Name   string
20571                                 Groups []Group
20572
20573                                 P1Type   Param1Type
20574                                 P2Type   Param2Type
20575                                 DrawType DrawType
20576
20577                                 Mesh  string
20578                                 Scale float32
20579                                 //mt:const uint8(6)
20580                                 Tiles        [6]TileDef
20581                                 OverlayTiles [6]TileDef
20582                                 //mt:const uint8(6)
20583                                 SpecialTiles [6]TileDef
20584
20585                                 Color   color.NRGBA
20586                                 Palette Texture
20587
20588                                 Waving       WaveType
20589                                 ConnectSides uint8
20590                                 ConnectTo    []Content
20591                                 InsideTint   color.NRGBA
20592                                 Level        uint8 // Must be < 128.
20593
20594                                 Translucent bool // Sunlight is scattered and becomes normal light.
20595                                 Transparent bool // Sunlight isn't scattered.
20596                                 LightSrc    uint8
20597
20598                                 GndContent   bool
20599                                 Collides     bool
20600                                 Pointable    bool
20601                                 Diggable     bool
20602                                 Climbable    bool
20603                                 Replaceable  bool
20604                                 OnRightClick bool
20605
20606                                 DmgPerSec int32
20607
20608                                 LiquidType   LiquidType
20609                                 FlowingAlt   string
20610                                 SrcAlt       string
20611                                 Viscosity    uint8 // 0-7
20612                                 LiqRenewable bool
20613                                 FlowRange    uint8
20614                                 DrownDmg     uint8
20615                                 Floodable    bool
20616
20617                                 DrawBox, ColBox, SelBox NodeBox
20618
20619                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20620
20621                                 LegacyFaceDir bool
20622                                 LegacyMounted bool
20623
20624                                 DigPredict string
20625
20626                                 MaxLvl uint8
20627
20628                                 AlphaUse
20629
20630                                 MoveResistance uint8
20631
20632                                 LiquidMovePhysics bool
20633                         }))(obj)).Waving).Deserialize(r)
20634                 }); err != nil {
20635                         if err == io.EOF {
20636                                 chk(io.EOF)
20637                         }
20638                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.WaveType", err))
20639                 }
20640                 {
20641                         p := &(*(*(struct {
20642                                 Param0 Content
20643
20644                                 Name   string
20645                                 Groups []Group
20646
20647                                 P1Type   Param1Type
20648                                 P2Type   Param2Type
20649                                 DrawType DrawType
20650
20651                                 Mesh  string
20652                                 Scale float32
20653                                 //mt:const uint8(6)
20654                                 Tiles        [6]TileDef
20655                                 OverlayTiles [6]TileDef
20656                                 //mt:const uint8(6)
20657                                 SpecialTiles [6]TileDef
20658
20659                                 Color   color.NRGBA
20660                                 Palette Texture
20661
20662                                 Waving       WaveType
20663                                 ConnectSides uint8
20664                                 ConnectTo    []Content
20665                                 InsideTint   color.NRGBA
20666                                 Level        uint8 // Must be < 128.
20667
20668                                 Translucent bool // Sunlight is scattered and becomes normal light.
20669                                 Transparent bool // Sunlight isn't scattered.
20670                                 LightSrc    uint8
20671
20672                                 GndContent   bool
20673                                 Collides     bool
20674                                 Pointable    bool
20675                                 Diggable     bool
20676                                 Climbable    bool
20677                                 Replaceable  bool
20678                                 OnRightClick bool
20679
20680                                 DmgPerSec int32
20681
20682                                 LiquidType   LiquidType
20683                                 FlowingAlt   string
20684                                 SrcAlt       string
20685                                 Viscosity    uint8 // 0-7
20686                                 LiqRenewable bool
20687                                 FlowRange    uint8
20688                                 DrownDmg     uint8
20689                                 Floodable    bool
20690
20691                                 DrawBox, ColBox, SelBox NodeBox
20692
20693                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20694
20695                                 LegacyFaceDir bool
20696                                 LegacyMounted bool
20697
20698                                 DigPredict string
20699
20700                                 MaxLvl uint8
20701
20702                                 AlphaUse
20703
20704                                 MoveResistance uint8
20705
20706                                 LiquidMovePhysics bool
20707                         }))(obj)).ConnectSides
20708                         *p = read8(r)
20709                 }
20710                 var local261 uint16
20711                 {
20712                         p := &local261
20713                         *p = read16(r)
20714                 }
20715                 ((*(*(struct {
20716                         Param0 Content
20717
20718                         Name   string
20719                         Groups []Group
20720
20721                         P1Type   Param1Type
20722                         P2Type   Param2Type
20723                         DrawType DrawType
20724
20725                         Mesh  string
20726                         Scale float32
20727                         //mt:const uint8(6)
20728                         Tiles        [6]TileDef
20729                         OverlayTiles [6]TileDef
20730                         //mt:const uint8(6)
20731                         SpecialTiles [6]TileDef
20732
20733                         Color   color.NRGBA
20734                         Palette Texture
20735
20736                         Waving       WaveType
20737                         ConnectSides uint8
20738                         ConnectTo    []Content
20739                         InsideTint   color.NRGBA
20740                         Level        uint8 // Must be < 128.
20741
20742                         Translucent bool // Sunlight is scattered and becomes normal light.
20743                         Transparent bool // Sunlight isn't scattered.
20744                         LightSrc    uint8
20745
20746                         GndContent   bool
20747                         Collides     bool
20748                         Pointable    bool
20749                         Diggable     bool
20750                         Climbable    bool
20751                         Replaceable  bool
20752                         OnRightClick bool
20753
20754                         DmgPerSec int32
20755
20756                         LiquidType   LiquidType
20757                         FlowingAlt   string
20758                         SrcAlt       string
20759                         Viscosity    uint8 // 0-7
20760                         LiqRenewable bool
20761                         FlowRange    uint8
20762                         DrownDmg     uint8
20763                         Floodable    bool
20764
20765                         DrawBox, ColBox, SelBox NodeBox
20766
20767                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20768
20769                         LegacyFaceDir bool
20770                         LegacyMounted bool
20771
20772                         DigPredict string
20773
20774                         MaxLvl uint8
20775
20776                         AlphaUse
20777
20778                         MoveResistance uint8
20779
20780                         LiquidMovePhysics bool
20781                 }))(obj)).ConnectTo) = make([]Content, local261)
20782                 for local262 := range (*(*(struct {
20783                         Param0 Content
20784
20785                         Name   string
20786                         Groups []Group
20787
20788                         P1Type   Param1Type
20789                         P2Type   Param2Type
20790                         DrawType DrawType
20791
20792                         Mesh  string
20793                         Scale float32
20794                         //mt:const uint8(6)
20795                         Tiles        [6]TileDef
20796                         OverlayTiles [6]TileDef
20797                         //mt:const uint8(6)
20798                         SpecialTiles [6]TileDef
20799
20800                         Color   color.NRGBA
20801                         Palette Texture
20802
20803                         Waving       WaveType
20804                         ConnectSides uint8
20805                         ConnectTo    []Content
20806                         InsideTint   color.NRGBA
20807                         Level        uint8 // Must be < 128.
20808
20809                         Translucent bool // Sunlight is scattered and becomes normal light.
20810                         Transparent bool // Sunlight isn't scattered.
20811                         LightSrc    uint8
20812
20813                         GndContent   bool
20814                         Collides     bool
20815                         Pointable    bool
20816                         Diggable     bool
20817                         Climbable    bool
20818                         Replaceable  bool
20819                         OnRightClick bool
20820
20821                         DmgPerSec int32
20822
20823                         LiquidType   LiquidType
20824                         FlowingAlt   string
20825                         SrcAlt       string
20826                         Viscosity    uint8 // 0-7
20827                         LiqRenewable bool
20828                         FlowRange    uint8
20829                         DrownDmg     uint8
20830                         Floodable    bool
20831
20832                         DrawBox, ColBox, SelBox NodeBox
20833
20834                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20835
20836                         LegacyFaceDir bool
20837                         LegacyMounted bool
20838
20839                         DigPredict string
20840
20841                         MaxLvl uint8
20842
20843                         AlphaUse
20844
20845                         MoveResistance uint8
20846
20847                         LiquidMovePhysics bool
20848                 }))(obj)).ConnectTo {
20849                         if err := pcall(func() {
20850                                 (((*(*(struct {
20851                                         Param0 Content
20852
20853                                         Name   string
20854                                         Groups []Group
20855
20856                                         P1Type   Param1Type
20857                                         P2Type   Param2Type
20858                                         DrawType DrawType
20859
20860                                         Mesh  string
20861                                         Scale float32
20862                                         //mt:const uint8(6)
20863                                         Tiles        [6]TileDef
20864                                         OverlayTiles [6]TileDef
20865                                         //mt:const uint8(6)
20866                                         SpecialTiles [6]TileDef
20867
20868                                         Color   color.NRGBA
20869                                         Palette Texture
20870
20871                                         Waving       WaveType
20872                                         ConnectSides uint8
20873                                         ConnectTo    []Content
20874                                         InsideTint   color.NRGBA
20875                                         Level        uint8 // Must be < 128.
20876
20877                                         Translucent bool // Sunlight is scattered and becomes normal light.
20878                                         Transparent bool // Sunlight isn't scattered.
20879                                         LightSrc    uint8
20880
20881                                         GndContent   bool
20882                                         Collides     bool
20883                                         Pointable    bool
20884                                         Diggable     bool
20885                                         Climbable    bool
20886                                         Replaceable  bool
20887                                         OnRightClick bool
20888
20889                                         DmgPerSec int32
20890
20891                                         LiquidType   LiquidType
20892                                         FlowingAlt   string
20893                                         SrcAlt       string
20894                                         Viscosity    uint8 // 0-7
20895                                         LiqRenewable bool
20896                                         FlowRange    uint8
20897                                         DrownDmg     uint8
20898                                         Floodable    bool
20899
20900                                         DrawBox, ColBox, SelBox NodeBox
20901
20902                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20903
20904                                         LegacyFaceDir bool
20905                                         LegacyMounted bool
20906
20907                                         DigPredict string
20908
20909                                         MaxLvl uint8
20910
20911                                         AlphaUse
20912
20913                                         MoveResistance uint8
20914
20915                                         LiquidMovePhysics bool
20916                                 }))(obj)).ConnectTo)[local262]).Deserialize(r)
20917                         }); err != nil {
20918                                 if err == io.EOF {
20919                                         chk(io.EOF)
20920                                 }
20921                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
20922                         }
20923                 }
20924                 {
20925                         p := &(*(*(struct {
20926                                 Param0 Content
20927
20928                                 Name   string
20929                                 Groups []Group
20930
20931                                 P1Type   Param1Type
20932                                 P2Type   Param2Type
20933                                 DrawType DrawType
20934
20935                                 Mesh  string
20936                                 Scale float32
20937                                 //mt:const uint8(6)
20938                                 Tiles        [6]TileDef
20939                                 OverlayTiles [6]TileDef
20940                                 //mt:const uint8(6)
20941                                 SpecialTiles [6]TileDef
20942
20943                                 Color   color.NRGBA
20944                                 Palette Texture
20945
20946                                 Waving       WaveType
20947                                 ConnectSides uint8
20948                                 ConnectTo    []Content
20949                                 InsideTint   color.NRGBA
20950                                 Level        uint8 // Must be < 128.
20951
20952                                 Translucent bool // Sunlight is scattered and becomes normal light.
20953                                 Transparent bool // Sunlight isn't scattered.
20954                                 LightSrc    uint8
20955
20956                                 GndContent   bool
20957                                 Collides     bool
20958                                 Pointable    bool
20959                                 Diggable     bool
20960                                 Climbable    bool
20961                                 Replaceable  bool
20962                                 OnRightClick bool
20963
20964                                 DmgPerSec int32
20965
20966                                 LiquidType   LiquidType
20967                                 FlowingAlt   string
20968                                 SrcAlt       string
20969                                 Viscosity    uint8 // 0-7
20970                                 LiqRenewable bool
20971                                 FlowRange    uint8
20972                                 DrownDmg     uint8
20973                                 Floodable    bool
20974
20975                                 DrawBox, ColBox, SelBox NodeBox
20976
20977                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20978
20979                                 LegacyFaceDir bool
20980                                 LegacyMounted bool
20981
20982                                 DigPredict string
20983
20984                                 MaxLvl uint8
20985
20986                                 AlphaUse
20987
20988                                 MoveResistance uint8
20989
20990                                 LiquidMovePhysics bool
20991                         }))(obj)).InsideTint
20992                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20993                 }
20994                 {
20995                         p := &(*(*(struct {
20996                                 Param0 Content
20997
20998                                 Name   string
20999                                 Groups []Group
21000
21001                                 P1Type   Param1Type
21002                                 P2Type   Param2Type
21003                                 DrawType DrawType
21004
21005                                 Mesh  string
21006                                 Scale float32
21007                                 //mt:const uint8(6)
21008                                 Tiles        [6]TileDef
21009                                 OverlayTiles [6]TileDef
21010                                 //mt:const uint8(6)
21011                                 SpecialTiles [6]TileDef
21012
21013                                 Color   color.NRGBA
21014                                 Palette Texture
21015
21016                                 Waving       WaveType
21017                                 ConnectSides uint8
21018                                 ConnectTo    []Content
21019                                 InsideTint   color.NRGBA
21020                                 Level        uint8 // Must be < 128.
21021
21022                                 Translucent bool // Sunlight is scattered and becomes normal light.
21023                                 Transparent bool // Sunlight isn't scattered.
21024                                 LightSrc    uint8
21025
21026                                 GndContent   bool
21027                                 Collides     bool
21028                                 Pointable    bool
21029                                 Diggable     bool
21030                                 Climbable    bool
21031                                 Replaceable  bool
21032                                 OnRightClick bool
21033
21034                                 DmgPerSec int32
21035
21036                                 LiquidType   LiquidType
21037                                 FlowingAlt   string
21038                                 SrcAlt       string
21039                                 Viscosity    uint8 // 0-7
21040                                 LiqRenewable bool
21041                                 FlowRange    uint8
21042                                 DrownDmg     uint8
21043                                 Floodable    bool
21044
21045                                 DrawBox, ColBox, SelBox NodeBox
21046
21047                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21048
21049                                 LegacyFaceDir bool
21050                                 LegacyMounted bool
21051
21052                                 DigPredict string
21053
21054                                 MaxLvl uint8
21055
21056                                 AlphaUse
21057
21058                                 MoveResistance uint8
21059
21060                                 LiquidMovePhysics bool
21061                         }))(obj)).Level
21062                         *p = read8(r)
21063                 }
21064                 {
21065                         p := &(*(*(struct {
21066                                 Param0 Content
21067
21068                                 Name   string
21069                                 Groups []Group
21070
21071                                 P1Type   Param1Type
21072                                 P2Type   Param2Type
21073                                 DrawType DrawType
21074
21075                                 Mesh  string
21076                                 Scale float32
21077                                 //mt:const uint8(6)
21078                                 Tiles        [6]TileDef
21079                                 OverlayTiles [6]TileDef
21080                                 //mt:const uint8(6)
21081                                 SpecialTiles [6]TileDef
21082
21083                                 Color   color.NRGBA
21084                                 Palette Texture
21085
21086                                 Waving       WaveType
21087                                 ConnectSides uint8
21088                                 ConnectTo    []Content
21089                                 InsideTint   color.NRGBA
21090                                 Level        uint8 // Must be < 128.
21091
21092                                 Translucent bool // Sunlight is scattered and becomes normal light.
21093                                 Transparent bool // Sunlight isn't scattered.
21094                                 LightSrc    uint8
21095
21096                                 GndContent   bool
21097                                 Collides     bool
21098                                 Pointable    bool
21099                                 Diggable     bool
21100                                 Climbable    bool
21101                                 Replaceable  bool
21102                                 OnRightClick bool
21103
21104                                 DmgPerSec int32
21105
21106                                 LiquidType   LiquidType
21107                                 FlowingAlt   string
21108                                 SrcAlt       string
21109                                 Viscosity    uint8 // 0-7
21110                                 LiqRenewable bool
21111                                 FlowRange    uint8
21112                                 DrownDmg     uint8
21113                                 Floodable    bool
21114
21115                                 DrawBox, ColBox, SelBox NodeBox
21116
21117                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21118
21119                                 LegacyFaceDir bool
21120                                 LegacyMounted bool
21121
21122                                 DigPredict string
21123
21124                                 MaxLvl uint8
21125
21126                                 AlphaUse
21127
21128                                 MoveResistance uint8
21129
21130                                 LiquidMovePhysics bool
21131                         }))(obj)).Translucent
21132                         switch n := read8(r); n {
21133                         case 0:
21134                                 *p = false
21135                         case 1:
21136                                 *p = true
21137                         default:
21138                                 chk(fmt.Errorf("invalid bool: %d", n))
21139                         }
21140                 }
21141                 {
21142                         p := &(*(*(struct {
21143                                 Param0 Content
21144
21145                                 Name   string
21146                                 Groups []Group
21147
21148                                 P1Type   Param1Type
21149                                 P2Type   Param2Type
21150                                 DrawType DrawType
21151
21152                                 Mesh  string
21153                                 Scale float32
21154                                 //mt:const uint8(6)
21155                                 Tiles        [6]TileDef
21156                                 OverlayTiles [6]TileDef
21157                                 //mt:const uint8(6)
21158                                 SpecialTiles [6]TileDef
21159
21160                                 Color   color.NRGBA
21161                                 Palette Texture
21162
21163                                 Waving       WaveType
21164                                 ConnectSides uint8
21165                                 ConnectTo    []Content
21166                                 InsideTint   color.NRGBA
21167                                 Level        uint8 // Must be < 128.
21168
21169                                 Translucent bool // Sunlight is scattered and becomes normal light.
21170                                 Transparent bool // Sunlight isn't scattered.
21171                                 LightSrc    uint8
21172
21173                                 GndContent   bool
21174                                 Collides     bool
21175                                 Pointable    bool
21176                                 Diggable     bool
21177                                 Climbable    bool
21178                                 Replaceable  bool
21179                                 OnRightClick bool
21180
21181                                 DmgPerSec int32
21182
21183                                 LiquidType   LiquidType
21184                                 FlowingAlt   string
21185                                 SrcAlt       string
21186                                 Viscosity    uint8 // 0-7
21187                                 LiqRenewable bool
21188                                 FlowRange    uint8
21189                                 DrownDmg     uint8
21190                                 Floodable    bool
21191
21192                                 DrawBox, ColBox, SelBox NodeBox
21193
21194                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21195
21196                                 LegacyFaceDir bool
21197                                 LegacyMounted bool
21198
21199                                 DigPredict string
21200
21201                                 MaxLvl uint8
21202
21203                                 AlphaUse
21204
21205                                 MoveResistance uint8
21206
21207                                 LiquidMovePhysics bool
21208                         }))(obj)).Transparent
21209                         switch n := read8(r); n {
21210                         case 0:
21211                                 *p = false
21212                         case 1:
21213                                 *p = true
21214                         default:
21215                                 chk(fmt.Errorf("invalid bool: %d", n))
21216                         }
21217                 }
21218                 {
21219                         p := &(*(*(struct {
21220                                 Param0 Content
21221
21222                                 Name   string
21223                                 Groups []Group
21224
21225                                 P1Type   Param1Type
21226                                 P2Type   Param2Type
21227                                 DrawType DrawType
21228
21229                                 Mesh  string
21230                                 Scale float32
21231                                 //mt:const uint8(6)
21232                                 Tiles        [6]TileDef
21233                                 OverlayTiles [6]TileDef
21234                                 //mt:const uint8(6)
21235                                 SpecialTiles [6]TileDef
21236
21237                                 Color   color.NRGBA
21238                                 Palette Texture
21239
21240                                 Waving       WaveType
21241                                 ConnectSides uint8
21242                                 ConnectTo    []Content
21243                                 InsideTint   color.NRGBA
21244                                 Level        uint8 // Must be < 128.
21245
21246                                 Translucent bool // Sunlight is scattered and becomes normal light.
21247                                 Transparent bool // Sunlight isn't scattered.
21248                                 LightSrc    uint8
21249
21250                                 GndContent   bool
21251                                 Collides     bool
21252                                 Pointable    bool
21253                                 Diggable     bool
21254                                 Climbable    bool
21255                                 Replaceable  bool
21256                                 OnRightClick bool
21257
21258                                 DmgPerSec int32
21259
21260                                 LiquidType   LiquidType
21261                                 FlowingAlt   string
21262                                 SrcAlt       string
21263                                 Viscosity    uint8 // 0-7
21264                                 LiqRenewable bool
21265                                 FlowRange    uint8
21266                                 DrownDmg     uint8
21267                                 Floodable    bool
21268
21269                                 DrawBox, ColBox, SelBox NodeBox
21270
21271                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21272
21273                                 LegacyFaceDir bool
21274                                 LegacyMounted bool
21275
21276                                 DigPredict string
21277
21278                                 MaxLvl uint8
21279
21280                                 AlphaUse
21281
21282                                 MoveResistance uint8
21283
21284                                 LiquidMovePhysics bool
21285                         }))(obj)).LightSrc
21286                         *p = read8(r)
21287                 }
21288                 {
21289                         p := &(*(*(struct {
21290                                 Param0 Content
21291
21292                                 Name   string
21293                                 Groups []Group
21294
21295                                 P1Type   Param1Type
21296                                 P2Type   Param2Type
21297                                 DrawType DrawType
21298
21299                                 Mesh  string
21300                                 Scale float32
21301                                 //mt:const uint8(6)
21302                                 Tiles        [6]TileDef
21303                                 OverlayTiles [6]TileDef
21304                                 //mt:const uint8(6)
21305                                 SpecialTiles [6]TileDef
21306
21307                                 Color   color.NRGBA
21308                                 Palette Texture
21309
21310                                 Waving       WaveType
21311                                 ConnectSides uint8
21312                                 ConnectTo    []Content
21313                                 InsideTint   color.NRGBA
21314                                 Level        uint8 // Must be < 128.
21315
21316                                 Translucent bool // Sunlight is scattered and becomes normal light.
21317                                 Transparent bool // Sunlight isn't scattered.
21318                                 LightSrc    uint8
21319
21320                                 GndContent   bool
21321                                 Collides     bool
21322                                 Pointable    bool
21323                                 Diggable     bool
21324                                 Climbable    bool
21325                                 Replaceable  bool
21326                                 OnRightClick bool
21327
21328                                 DmgPerSec int32
21329
21330                                 LiquidType   LiquidType
21331                                 FlowingAlt   string
21332                                 SrcAlt       string
21333                                 Viscosity    uint8 // 0-7
21334                                 LiqRenewable bool
21335                                 FlowRange    uint8
21336                                 DrownDmg     uint8
21337                                 Floodable    bool
21338
21339                                 DrawBox, ColBox, SelBox NodeBox
21340
21341                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21342
21343                                 LegacyFaceDir bool
21344                                 LegacyMounted bool
21345
21346                                 DigPredict string
21347
21348                                 MaxLvl uint8
21349
21350                                 AlphaUse
21351
21352                                 MoveResistance uint8
21353
21354                                 LiquidMovePhysics bool
21355                         }))(obj)).GndContent
21356                         switch n := read8(r); n {
21357                         case 0:
21358                                 *p = false
21359                         case 1:
21360                                 *p = true
21361                         default:
21362                                 chk(fmt.Errorf("invalid bool: %d", n))
21363                         }
21364                 }
21365                 {
21366                         p := &(*(*(struct {
21367                                 Param0 Content
21368
21369                                 Name   string
21370                                 Groups []Group
21371
21372                                 P1Type   Param1Type
21373                                 P2Type   Param2Type
21374                                 DrawType DrawType
21375
21376                                 Mesh  string
21377                                 Scale float32
21378                                 //mt:const uint8(6)
21379                                 Tiles        [6]TileDef
21380                                 OverlayTiles [6]TileDef
21381                                 //mt:const uint8(6)
21382                                 SpecialTiles [6]TileDef
21383
21384                                 Color   color.NRGBA
21385                                 Palette Texture
21386
21387                                 Waving       WaveType
21388                                 ConnectSides uint8
21389                                 ConnectTo    []Content
21390                                 InsideTint   color.NRGBA
21391                                 Level        uint8 // Must be < 128.
21392
21393                                 Translucent bool // Sunlight is scattered and becomes normal light.
21394                                 Transparent bool // Sunlight isn't scattered.
21395                                 LightSrc    uint8
21396
21397                                 GndContent   bool
21398                                 Collides     bool
21399                                 Pointable    bool
21400                                 Diggable     bool
21401                                 Climbable    bool
21402                                 Replaceable  bool
21403                                 OnRightClick bool
21404
21405                                 DmgPerSec int32
21406
21407                                 LiquidType   LiquidType
21408                                 FlowingAlt   string
21409                                 SrcAlt       string
21410                                 Viscosity    uint8 // 0-7
21411                                 LiqRenewable bool
21412                                 FlowRange    uint8
21413                                 DrownDmg     uint8
21414                                 Floodable    bool
21415
21416                                 DrawBox, ColBox, SelBox NodeBox
21417
21418                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21419
21420                                 LegacyFaceDir bool
21421                                 LegacyMounted bool
21422
21423                                 DigPredict string
21424
21425                                 MaxLvl uint8
21426
21427                                 AlphaUse
21428
21429                                 MoveResistance uint8
21430
21431                                 LiquidMovePhysics bool
21432                         }))(obj)).Collides
21433                         switch n := read8(r); n {
21434                         case 0:
21435                                 *p = false
21436                         case 1:
21437                                 *p = true
21438                         default:
21439                                 chk(fmt.Errorf("invalid bool: %d", n))
21440                         }
21441                 }
21442                 {
21443                         p := &(*(*(struct {
21444                                 Param0 Content
21445
21446                                 Name   string
21447                                 Groups []Group
21448
21449                                 P1Type   Param1Type
21450                                 P2Type   Param2Type
21451                                 DrawType DrawType
21452
21453                                 Mesh  string
21454                                 Scale float32
21455                                 //mt:const uint8(6)
21456                                 Tiles        [6]TileDef
21457                                 OverlayTiles [6]TileDef
21458                                 //mt:const uint8(6)
21459                                 SpecialTiles [6]TileDef
21460
21461                                 Color   color.NRGBA
21462                                 Palette Texture
21463
21464                                 Waving       WaveType
21465                                 ConnectSides uint8
21466                                 ConnectTo    []Content
21467                                 InsideTint   color.NRGBA
21468                                 Level        uint8 // Must be < 128.
21469
21470                                 Translucent bool // Sunlight is scattered and becomes normal light.
21471                                 Transparent bool // Sunlight isn't scattered.
21472                                 LightSrc    uint8
21473
21474                                 GndContent   bool
21475                                 Collides     bool
21476                                 Pointable    bool
21477                                 Diggable     bool
21478                                 Climbable    bool
21479                                 Replaceable  bool
21480                                 OnRightClick bool
21481
21482                                 DmgPerSec int32
21483
21484                                 LiquidType   LiquidType
21485                                 FlowingAlt   string
21486                                 SrcAlt       string
21487                                 Viscosity    uint8 // 0-7
21488                                 LiqRenewable bool
21489                                 FlowRange    uint8
21490                                 DrownDmg     uint8
21491                                 Floodable    bool
21492
21493                                 DrawBox, ColBox, SelBox NodeBox
21494
21495                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21496
21497                                 LegacyFaceDir bool
21498                                 LegacyMounted bool
21499
21500                                 DigPredict string
21501
21502                                 MaxLvl uint8
21503
21504                                 AlphaUse
21505
21506                                 MoveResistance uint8
21507
21508                                 LiquidMovePhysics bool
21509                         }))(obj)).Pointable
21510                         switch n := read8(r); n {
21511                         case 0:
21512                                 *p = false
21513                         case 1:
21514                                 *p = true
21515                         default:
21516                                 chk(fmt.Errorf("invalid bool: %d", n))
21517                         }
21518                 }
21519                 {
21520                         p := &(*(*(struct {
21521                                 Param0 Content
21522
21523                                 Name   string
21524                                 Groups []Group
21525
21526                                 P1Type   Param1Type
21527                                 P2Type   Param2Type
21528                                 DrawType DrawType
21529
21530                                 Mesh  string
21531                                 Scale float32
21532                                 //mt:const uint8(6)
21533                                 Tiles        [6]TileDef
21534                                 OverlayTiles [6]TileDef
21535                                 //mt:const uint8(6)
21536                                 SpecialTiles [6]TileDef
21537
21538                                 Color   color.NRGBA
21539                                 Palette Texture
21540
21541                                 Waving       WaveType
21542                                 ConnectSides uint8
21543                                 ConnectTo    []Content
21544                                 InsideTint   color.NRGBA
21545                                 Level        uint8 // Must be < 128.
21546
21547                                 Translucent bool // Sunlight is scattered and becomes normal light.
21548                                 Transparent bool // Sunlight isn't scattered.
21549                                 LightSrc    uint8
21550
21551                                 GndContent   bool
21552                                 Collides     bool
21553                                 Pointable    bool
21554                                 Diggable     bool
21555                                 Climbable    bool
21556                                 Replaceable  bool
21557                                 OnRightClick bool
21558
21559                                 DmgPerSec int32
21560
21561                                 LiquidType   LiquidType
21562                                 FlowingAlt   string
21563                                 SrcAlt       string
21564                                 Viscosity    uint8 // 0-7
21565                                 LiqRenewable bool
21566                                 FlowRange    uint8
21567                                 DrownDmg     uint8
21568                                 Floodable    bool
21569
21570                                 DrawBox, ColBox, SelBox NodeBox
21571
21572                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21573
21574                                 LegacyFaceDir bool
21575                                 LegacyMounted bool
21576
21577                                 DigPredict string
21578
21579                                 MaxLvl uint8
21580
21581                                 AlphaUse
21582
21583                                 MoveResistance uint8
21584
21585                                 LiquidMovePhysics bool
21586                         }))(obj)).Diggable
21587                         switch n := read8(r); n {
21588                         case 0:
21589                                 *p = false
21590                         case 1:
21591                                 *p = true
21592                         default:
21593                                 chk(fmt.Errorf("invalid bool: %d", n))
21594                         }
21595                 }
21596                 {
21597                         p := &(*(*(struct {
21598                                 Param0 Content
21599
21600                                 Name   string
21601                                 Groups []Group
21602
21603                                 P1Type   Param1Type
21604                                 P2Type   Param2Type
21605                                 DrawType DrawType
21606
21607                                 Mesh  string
21608                                 Scale float32
21609                                 //mt:const uint8(6)
21610                                 Tiles        [6]TileDef
21611                                 OverlayTiles [6]TileDef
21612                                 //mt:const uint8(6)
21613                                 SpecialTiles [6]TileDef
21614
21615                                 Color   color.NRGBA
21616                                 Palette Texture
21617
21618                                 Waving       WaveType
21619                                 ConnectSides uint8
21620                                 ConnectTo    []Content
21621                                 InsideTint   color.NRGBA
21622                                 Level        uint8 // Must be < 128.
21623
21624                                 Translucent bool // Sunlight is scattered and becomes normal light.
21625                                 Transparent bool // Sunlight isn't scattered.
21626                                 LightSrc    uint8
21627
21628                                 GndContent   bool
21629                                 Collides     bool
21630                                 Pointable    bool
21631                                 Diggable     bool
21632                                 Climbable    bool
21633                                 Replaceable  bool
21634                                 OnRightClick bool
21635
21636                                 DmgPerSec int32
21637
21638                                 LiquidType   LiquidType
21639                                 FlowingAlt   string
21640                                 SrcAlt       string
21641                                 Viscosity    uint8 // 0-7
21642                                 LiqRenewable bool
21643                                 FlowRange    uint8
21644                                 DrownDmg     uint8
21645                                 Floodable    bool
21646
21647                                 DrawBox, ColBox, SelBox NodeBox
21648
21649                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21650
21651                                 LegacyFaceDir bool
21652                                 LegacyMounted bool
21653
21654                                 DigPredict string
21655
21656                                 MaxLvl uint8
21657
21658                                 AlphaUse
21659
21660                                 MoveResistance uint8
21661
21662                                 LiquidMovePhysics bool
21663                         }))(obj)).Climbable
21664                         switch n := read8(r); n {
21665                         case 0:
21666                                 *p = false
21667                         case 1:
21668                                 *p = true
21669                         default:
21670                                 chk(fmt.Errorf("invalid bool: %d", n))
21671                         }
21672                 }
21673                 {
21674                         p := &(*(*(struct {
21675                                 Param0 Content
21676
21677                                 Name   string
21678                                 Groups []Group
21679
21680                                 P1Type   Param1Type
21681                                 P2Type   Param2Type
21682                                 DrawType DrawType
21683
21684                                 Mesh  string
21685                                 Scale float32
21686                                 //mt:const uint8(6)
21687                                 Tiles        [6]TileDef
21688                                 OverlayTiles [6]TileDef
21689                                 //mt:const uint8(6)
21690                                 SpecialTiles [6]TileDef
21691
21692                                 Color   color.NRGBA
21693                                 Palette Texture
21694
21695                                 Waving       WaveType
21696                                 ConnectSides uint8
21697                                 ConnectTo    []Content
21698                                 InsideTint   color.NRGBA
21699                                 Level        uint8 // Must be < 128.
21700
21701                                 Translucent bool // Sunlight is scattered and becomes normal light.
21702                                 Transparent bool // Sunlight isn't scattered.
21703                                 LightSrc    uint8
21704
21705                                 GndContent   bool
21706                                 Collides     bool
21707                                 Pointable    bool
21708                                 Diggable     bool
21709                                 Climbable    bool
21710                                 Replaceable  bool
21711                                 OnRightClick bool
21712
21713                                 DmgPerSec int32
21714
21715                                 LiquidType   LiquidType
21716                                 FlowingAlt   string
21717                                 SrcAlt       string
21718                                 Viscosity    uint8 // 0-7
21719                                 LiqRenewable bool
21720                                 FlowRange    uint8
21721                                 DrownDmg     uint8
21722                                 Floodable    bool
21723
21724                                 DrawBox, ColBox, SelBox NodeBox
21725
21726                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21727
21728                                 LegacyFaceDir bool
21729                                 LegacyMounted bool
21730
21731                                 DigPredict string
21732
21733                                 MaxLvl uint8
21734
21735                                 AlphaUse
21736
21737                                 MoveResistance uint8
21738
21739                                 LiquidMovePhysics bool
21740                         }))(obj)).Replaceable
21741                         switch n := read8(r); n {
21742                         case 0:
21743                                 *p = false
21744                         case 1:
21745                                 *p = true
21746                         default:
21747                                 chk(fmt.Errorf("invalid bool: %d", n))
21748                         }
21749                 }
21750                 {
21751                         p := &(*(*(struct {
21752                                 Param0 Content
21753
21754                                 Name   string
21755                                 Groups []Group
21756
21757                                 P1Type   Param1Type
21758                                 P2Type   Param2Type
21759                                 DrawType DrawType
21760
21761                                 Mesh  string
21762                                 Scale float32
21763                                 //mt:const uint8(6)
21764                                 Tiles        [6]TileDef
21765                                 OverlayTiles [6]TileDef
21766                                 //mt:const uint8(6)
21767                                 SpecialTiles [6]TileDef
21768
21769                                 Color   color.NRGBA
21770                                 Palette Texture
21771
21772                                 Waving       WaveType
21773                                 ConnectSides uint8
21774                                 ConnectTo    []Content
21775                                 InsideTint   color.NRGBA
21776                                 Level        uint8 // Must be < 128.
21777
21778                                 Translucent bool // Sunlight is scattered and becomes normal light.
21779                                 Transparent bool // Sunlight isn't scattered.
21780                                 LightSrc    uint8
21781
21782                                 GndContent   bool
21783                                 Collides     bool
21784                                 Pointable    bool
21785                                 Diggable     bool
21786                                 Climbable    bool
21787                                 Replaceable  bool
21788                                 OnRightClick bool
21789
21790                                 DmgPerSec int32
21791
21792                                 LiquidType   LiquidType
21793                                 FlowingAlt   string
21794                                 SrcAlt       string
21795                                 Viscosity    uint8 // 0-7
21796                                 LiqRenewable bool
21797                                 FlowRange    uint8
21798                                 DrownDmg     uint8
21799                                 Floodable    bool
21800
21801                                 DrawBox, ColBox, SelBox NodeBox
21802
21803                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21804
21805                                 LegacyFaceDir bool
21806                                 LegacyMounted bool
21807
21808                                 DigPredict string
21809
21810                                 MaxLvl uint8
21811
21812                                 AlphaUse
21813
21814                                 MoveResistance uint8
21815
21816                                 LiquidMovePhysics bool
21817                         }))(obj)).OnRightClick
21818                         switch n := read8(r); n {
21819                         case 0:
21820                                 *p = false
21821                         case 1:
21822                                 *p = true
21823                         default:
21824                                 chk(fmt.Errorf("invalid bool: %d", n))
21825                         }
21826                 }
21827                 {
21828                         p := &(*(*(struct {
21829                                 Param0 Content
21830
21831                                 Name   string
21832                                 Groups []Group
21833
21834                                 P1Type   Param1Type
21835                                 P2Type   Param2Type
21836                                 DrawType DrawType
21837
21838                                 Mesh  string
21839                                 Scale float32
21840                                 //mt:const uint8(6)
21841                                 Tiles        [6]TileDef
21842                                 OverlayTiles [6]TileDef
21843                                 //mt:const uint8(6)
21844                                 SpecialTiles [6]TileDef
21845
21846                                 Color   color.NRGBA
21847                                 Palette Texture
21848
21849                                 Waving       WaveType
21850                                 ConnectSides uint8
21851                                 ConnectTo    []Content
21852                                 InsideTint   color.NRGBA
21853                                 Level        uint8 // Must be < 128.
21854
21855                                 Translucent bool // Sunlight is scattered and becomes normal light.
21856                                 Transparent bool // Sunlight isn't scattered.
21857                                 LightSrc    uint8
21858
21859                                 GndContent   bool
21860                                 Collides     bool
21861                                 Pointable    bool
21862                                 Diggable     bool
21863                                 Climbable    bool
21864                                 Replaceable  bool
21865                                 OnRightClick bool
21866
21867                                 DmgPerSec int32
21868
21869                                 LiquidType   LiquidType
21870                                 FlowingAlt   string
21871                                 SrcAlt       string
21872                                 Viscosity    uint8 // 0-7
21873                                 LiqRenewable bool
21874                                 FlowRange    uint8
21875                                 DrownDmg     uint8
21876                                 Floodable    bool
21877
21878                                 DrawBox, ColBox, SelBox NodeBox
21879
21880                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21881
21882                                 LegacyFaceDir bool
21883                                 LegacyMounted bool
21884
21885                                 DigPredict string
21886
21887                                 MaxLvl uint8
21888
21889                                 AlphaUse
21890
21891                                 MoveResistance uint8
21892
21893                                 LiquidMovePhysics bool
21894                         }))(obj)).DmgPerSec
21895                         *p = int32(read32(r))
21896                 }
21897                 if err := pcall(func() {
21898                         ((*(*(struct {
21899                                 Param0 Content
21900
21901                                 Name   string
21902                                 Groups []Group
21903
21904                                 P1Type   Param1Type
21905                                 P2Type   Param2Type
21906                                 DrawType DrawType
21907
21908                                 Mesh  string
21909                                 Scale float32
21910                                 //mt:const uint8(6)
21911                                 Tiles        [6]TileDef
21912                                 OverlayTiles [6]TileDef
21913                                 //mt:const uint8(6)
21914                                 SpecialTiles [6]TileDef
21915
21916                                 Color   color.NRGBA
21917                                 Palette Texture
21918
21919                                 Waving       WaveType
21920                                 ConnectSides uint8
21921                                 ConnectTo    []Content
21922                                 InsideTint   color.NRGBA
21923                                 Level        uint8 // Must be < 128.
21924
21925                                 Translucent bool // Sunlight is scattered and becomes normal light.
21926                                 Transparent bool // Sunlight isn't scattered.
21927                                 LightSrc    uint8
21928
21929                                 GndContent   bool
21930                                 Collides     bool
21931                                 Pointable    bool
21932                                 Diggable     bool
21933                                 Climbable    bool
21934                                 Replaceable  bool
21935                                 OnRightClick bool
21936
21937                                 DmgPerSec int32
21938
21939                                 LiquidType   LiquidType
21940                                 FlowingAlt   string
21941                                 SrcAlt       string
21942                                 Viscosity    uint8 // 0-7
21943                                 LiqRenewable bool
21944                                 FlowRange    uint8
21945                                 DrownDmg     uint8
21946                                 Floodable    bool
21947
21948                                 DrawBox, ColBox, SelBox NodeBox
21949
21950                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21951
21952                                 LegacyFaceDir bool
21953                                 LegacyMounted bool
21954
21955                                 DigPredict string
21956
21957                                 MaxLvl uint8
21958
21959                                 AlphaUse
21960
21961                                 MoveResistance uint8
21962
21963                                 LiquidMovePhysics bool
21964                         }))(obj)).LiquidType).Deserialize(r)
21965                 }); err != nil {
21966                         if err == io.EOF {
21967                                 chk(io.EOF)
21968                         }
21969                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LiquidType", err))
21970                 }
21971                 var local263 []uint8
21972                 var local264 uint16
21973                 {
21974                         p := &local264
21975                         *p = read16(r)
21976                 }
21977                 (local263) = make([]uint8, local264)
21978                 {
21979                         _, err := io.ReadFull(r, (local263)[:])
21980                         chk(err)
21981                 }
21982                 ((*(*(struct {
21983                         Param0 Content
21984
21985                         Name   string
21986                         Groups []Group
21987
21988                         P1Type   Param1Type
21989                         P2Type   Param2Type
21990                         DrawType DrawType
21991
21992                         Mesh  string
21993                         Scale float32
21994                         //mt:const uint8(6)
21995                         Tiles        [6]TileDef
21996                         OverlayTiles [6]TileDef
21997                         //mt:const uint8(6)
21998                         SpecialTiles [6]TileDef
21999
22000                         Color   color.NRGBA
22001                         Palette Texture
22002
22003                         Waving       WaveType
22004                         ConnectSides uint8
22005                         ConnectTo    []Content
22006                         InsideTint   color.NRGBA
22007                         Level        uint8 // Must be < 128.
22008
22009                         Translucent bool // Sunlight is scattered and becomes normal light.
22010                         Transparent bool // Sunlight isn't scattered.
22011                         LightSrc    uint8
22012
22013                         GndContent   bool
22014                         Collides     bool
22015                         Pointable    bool
22016                         Diggable     bool
22017                         Climbable    bool
22018                         Replaceable  bool
22019                         OnRightClick bool
22020
22021                         DmgPerSec int32
22022
22023                         LiquidType   LiquidType
22024                         FlowingAlt   string
22025                         SrcAlt       string
22026                         Viscosity    uint8 // 0-7
22027                         LiqRenewable bool
22028                         FlowRange    uint8
22029                         DrownDmg     uint8
22030                         Floodable    bool
22031
22032                         DrawBox, ColBox, SelBox NodeBox
22033
22034                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22035
22036                         LegacyFaceDir bool
22037                         LegacyMounted bool
22038
22039                         DigPredict string
22040
22041                         MaxLvl uint8
22042
22043                         AlphaUse
22044
22045                         MoveResistance uint8
22046
22047                         LiquidMovePhysics bool
22048                 }))(obj)).FlowingAlt) = string(local263)
22049                 var local265 []uint8
22050                 var local266 uint16
22051                 {
22052                         p := &local266
22053                         *p = read16(r)
22054                 }
22055                 (local265) = make([]uint8, local266)
22056                 {
22057                         _, err := io.ReadFull(r, (local265)[:])
22058                         chk(err)
22059                 }
22060                 ((*(*(struct {
22061                         Param0 Content
22062
22063                         Name   string
22064                         Groups []Group
22065
22066                         P1Type   Param1Type
22067                         P2Type   Param2Type
22068                         DrawType DrawType
22069
22070                         Mesh  string
22071                         Scale float32
22072                         //mt:const uint8(6)
22073                         Tiles        [6]TileDef
22074                         OverlayTiles [6]TileDef
22075                         //mt:const uint8(6)
22076                         SpecialTiles [6]TileDef
22077
22078                         Color   color.NRGBA
22079                         Palette Texture
22080
22081                         Waving       WaveType
22082                         ConnectSides uint8
22083                         ConnectTo    []Content
22084                         InsideTint   color.NRGBA
22085                         Level        uint8 // Must be < 128.
22086
22087                         Translucent bool // Sunlight is scattered and becomes normal light.
22088                         Transparent bool // Sunlight isn't scattered.
22089                         LightSrc    uint8
22090
22091                         GndContent   bool
22092                         Collides     bool
22093                         Pointable    bool
22094                         Diggable     bool
22095                         Climbable    bool
22096                         Replaceable  bool
22097                         OnRightClick bool
22098
22099                         DmgPerSec int32
22100
22101                         LiquidType   LiquidType
22102                         FlowingAlt   string
22103                         SrcAlt       string
22104                         Viscosity    uint8 // 0-7
22105                         LiqRenewable bool
22106                         FlowRange    uint8
22107                         DrownDmg     uint8
22108                         Floodable    bool
22109
22110                         DrawBox, ColBox, SelBox NodeBox
22111
22112                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22113
22114                         LegacyFaceDir bool
22115                         LegacyMounted bool
22116
22117                         DigPredict string
22118
22119                         MaxLvl uint8
22120
22121                         AlphaUse
22122
22123                         MoveResistance uint8
22124
22125                         LiquidMovePhysics bool
22126                 }))(obj)).SrcAlt) = string(local265)
22127                 {
22128                         p := &(*(*(struct {
22129                                 Param0 Content
22130
22131                                 Name   string
22132                                 Groups []Group
22133
22134                                 P1Type   Param1Type
22135                                 P2Type   Param2Type
22136                                 DrawType DrawType
22137
22138                                 Mesh  string
22139                                 Scale float32
22140                                 //mt:const uint8(6)
22141                                 Tiles        [6]TileDef
22142                                 OverlayTiles [6]TileDef
22143                                 //mt:const uint8(6)
22144                                 SpecialTiles [6]TileDef
22145
22146                                 Color   color.NRGBA
22147                                 Palette Texture
22148
22149                                 Waving       WaveType
22150                                 ConnectSides uint8
22151                                 ConnectTo    []Content
22152                                 InsideTint   color.NRGBA
22153                                 Level        uint8 // Must be < 128.
22154
22155                                 Translucent bool // Sunlight is scattered and becomes normal light.
22156                                 Transparent bool // Sunlight isn't scattered.
22157                                 LightSrc    uint8
22158
22159                                 GndContent   bool
22160                                 Collides     bool
22161                                 Pointable    bool
22162                                 Diggable     bool
22163                                 Climbable    bool
22164                                 Replaceable  bool
22165                                 OnRightClick bool
22166
22167                                 DmgPerSec int32
22168
22169                                 LiquidType   LiquidType
22170                                 FlowingAlt   string
22171                                 SrcAlt       string
22172                                 Viscosity    uint8 // 0-7
22173                                 LiqRenewable bool
22174                                 FlowRange    uint8
22175                                 DrownDmg     uint8
22176                                 Floodable    bool
22177
22178                                 DrawBox, ColBox, SelBox NodeBox
22179
22180                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22181
22182                                 LegacyFaceDir bool
22183                                 LegacyMounted bool
22184
22185                                 DigPredict string
22186
22187                                 MaxLvl uint8
22188
22189                                 AlphaUse
22190
22191                                 MoveResistance uint8
22192
22193                                 LiquidMovePhysics bool
22194                         }))(obj)).Viscosity
22195                         *p = read8(r)
22196                 }
22197                 {
22198                         p := &(*(*(struct {
22199                                 Param0 Content
22200
22201                                 Name   string
22202                                 Groups []Group
22203
22204                                 P1Type   Param1Type
22205                                 P2Type   Param2Type
22206                                 DrawType DrawType
22207
22208                                 Mesh  string
22209                                 Scale float32
22210                                 //mt:const uint8(6)
22211                                 Tiles        [6]TileDef
22212                                 OverlayTiles [6]TileDef
22213                                 //mt:const uint8(6)
22214                                 SpecialTiles [6]TileDef
22215
22216                                 Color   color.NRGBA
22217                                 Palette Texture
22218
22219                                 Waving       WaveType
22220                                 ConnectSides uint8
22221                                 ConnectTo    []Content
22222                                 InsideTint   color.NRGBA
22223                                 Level        uint8 // Must be < 128.
22224
22225                                 Translucent bool // Sunlight is scattered and becomes normal light.
22226                                 Transparent bool // Sunlight isn't scattered.
22227                                 LightSrc    uint8
22228
22229                                 GndContent   bool
22230                                 Collides     bool
22231                                 Pointable    bool
22232                                 Diggable     bool
22233                                 Climbable    bool
22234                                 Replaceable  bool
22235                                 OnRightClick bool
22236
22237                                 DmgPerSec int32
22238
22239                                 LiquidType   LiquidType
22240                                 FlowingAlt   string
22241                                 SrcAlt       string
22242                                 Viscosity    uint8 // 0-7
22243                                 LiqRenewable bool
22244                                 FlowRange    uint8
22245                                 DrownDmg     uint8
22246                                 Floodable    bool
22247
22248                                 DrawBox, ColBox, SelBox NodeBox
22249
22250                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22251
22252                                 LegacyFaceDir bool
22253                                 LegacyMounted bool
22254
22255                                 DigPredict string
22256
22257                                 MaxLvl uint8
22258
22259                                 AlphaUse
22260
22261                                 MoveResistance uint8
22262
22263                                 LiquidMovePhysics bool
22264                         }))(obj)).LiqRenewable
22265                         switch n := read8(r); n {
22266                         case 0:
22267                                 *p = false
22268                         case 1:
22269                                 *p = true
22270                         default:
22271                                 chk(fmt.Errorf("invalid bool: %d", n))
22272                         }
22273                 }
22274                 {
22275                         p := &(*(*(struct {
22276                                 Param0 Content
22277
22278                                 Name   string
22279                                 Groups []Group
22280
22281                                 P1Type   Param1Type
22282                                 P2Type   Param2Type
22283                                 DrawType DrawType
22284
22285                                 Mesh  string
22286                                 Scale float32
22287                                 //mt:const uint8(6)
22288                                 Tiles        [6]TileDef
22289                                 OverlayTiles [6]TileDef
22290                                 //mt:const uint8(6)
22291                                 SpecialTiles [6]TileDef
22292
22293                                 Color   color.NRGBA
22294                                 Palette Texture
22295
22296                                 Waving       WaveType
22297                                 ConnectSides uint8
22298                                 ConnectTo    []Content
22299                                 InsideTint   color.NRGBA
22300                                 Level        uint8 // Must be < 128.
22301
22302                                 Translucent bool // Sunlight is scattered and becomes normal light.
22303                                 Transparent bool // Sunlight isn't scattered.
22304                                 LightSrc    uint8
22305
22306                                 GndContent   bool
22307                                 Collides     bool
22308                                 Pointable    bool
22309                                 Diggable     bool
22310                                 Climbable    bool
22311                                 Replaceable  bool
22312                                 OnRightClick bool
22313
22314                                 DmgPerSec int32
22315
22316                                 LiquidType   LiquidType
22317                                 FlowingAlt   string
22318                                 SrcAlt       string
22319                                 Viscosity    uint8 // 0-7
22320                                 LiqRenewable bool
22321                                 FlowRange    uint8
22322                                 DrownDmg     uint8
22323                                 Floodable    bool
22324
22325                                 DrawBox, ColBox, SelBox NodeBox
22326
22327                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22328
22329                                 LegacyFaceDir bool
22330                                 LegacyMounted bool
22331
22332                                 DigPredict string
22333
22334                                 MaxLvl uint8
22335
22336                                 AlphaUse
22337
22338                                 MoveResistance uint8
22339
22340                                 LiquidMovePhysics bool
22341                         }))(obj)).FlowRange
22342                         *p = read8(r)
22343                 }
22344                 {
22345                         p := &(*(*(struct {
22346                                 Param0 Content
22347
22348                                 Name   string
22349                                 Groups []Group
22350
22351                                 P1Type   Param1Type
22352                                 P2Type   Param2Type
22353                                 DrawType DrawType
22354
22355                                 Mesh  string
22356                                 Scale float32
22357                                 //mt:const uint8(6)
22358                                 Tiles        [6]TileDef
22359                                 OverlayTiles [6]TileDef
22360                                 //mt:const uint8(6)
22361                                 SpecialTiles [6]TileDef
22362
22363                                 Color   color.NRGBA
22364                                 Palette Texture
22365
22366                                 Waving       WaveType
22367                                 ConnectSides uint8
22368                                 ConnectTo    []Content
22369                                 InsideTint   color.NRGBA
22370                                 Level        uint8 // Must be < 128.
22371
22372                                 Translucent bool // Sunlight is scattered and becomes normal light.
22373                                 Transparent bool // Sunlight isn't scattered.
22374                                 LightSrc    uint8
22375
22376                                 GndContent   bool
22377                                 Collides     bool
22378                                 Pointable    bool
22379                                 Diggable     bool
22380                                 Climbable    bool
22381                                 Replaceable  bool
22382                                 OnRightClick bool
22383
22384                                 DmgPerSec int32
22385
22386                                 LiquidType   LiquidType
22387                                 FlowingAlt   string
22388                                 SrcAlt       string
22389                                 Viscosity    uint8 // 0-7
22390                                 LiqRenewable bool
22391                                 FlowRange    uint8
22392                                 DrownDmg     uint8
22393                                 Floodable    bool
22394
22395                                 DrawBox, ColBox, SelBox NodeBox
22396
22397                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22398
22399                                 LegacyFaceDir bool
22400                                 LegacyMounted bool
22401
22402                                 DigPredict string
22403
22404                                 MaxLvl uint8
22405
22406                                 AlphaUse
22407
22408                                 MoveResistance uint8
22409
22410                                 LiquidMovePhysics bool
22411                         }))(obj)).DrownDmg
22412                         *p = read8(r)
22413                 }
22414                 {
22415                         p := &(*(*(struct {
22416                                 Param0 Content
22417
22418                                 Name   string
22419                                 Groups []Group
22420
22421                                 P1Type   Param1Type
22422                                 P2Type   Param2Type
22423                                 DrawType DrawType
22424
22425                                 Mesh  string
22426                                 Scale float32
22427                                 //mt:const uint8(6)
22428                                 Tiles        [6]TileDef
22429                                 OverlayTiles [6]TileDef
22430                                 //mt:const uint8(6)
22431                                 SpecialTiles [6]TileDef
22432
22433                                 Color   color.NRGBA
22434                                 Palette Texture
22435
22436                                 Waving       WaveType
22437                                 ConnectSides uint8
22438                                 ConnectTo    []Content
22439                                 InsideTint   color.NRGBA
22440                                 Level        uint8 // Must be < 128.
22441
22442                                 Translucent bool // Sunlight is scattered and becomes normal light.
22443                                 Transparent bool // Sunlight isn't scattered.
22444                                 LightSrc    uint8
22445
22446                                 GndContent   bool
22447                                 Collides     bool
22448                                 Pointable    bool
22449                                 Diggable     bool
22450                                 Climbable    bool
22451                                 Replaceable  bool
22452                                 OnRightClick bool
22453
22454                                 DmgPerSec int32
22455
22456                                 LiquidType   LiquidType
22457                                 FlowingAlt   string
22458                                 SrcAlt       string
22459                                 Viscosity    uint8 // 0-7
22460                                 LiqRenewable bool
22461                                 FlowRange    uint8
22462                                 DrownDmg     uint8
22463                                 Floodable    bool
22464
22465                                 DrawBox, ColBox, SelBox NodeBox
22466
22467                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22468
22469                                 LegacyFaceDir bool
22470                                 LegacyMounted bool
22471
22472                                 DigPredict string
22473
22474                                 MaxLvl uint8
22475
22476                                 AlphaUse
22477
22478                                 MoveResistance uint8
22479
22480                                 LiquidMovePhysics bool
22481                         }))(obj)).Floodable
22482                         switch n := read8(r); n {
22483                         case 0:
22484                                 *p = false
22485                         case 1:
22486                                 *p = true
22487                         default:
22488                                 chk(fmt.Errorf("invalid bool: %d", n))
22489                         }
22490                 }
22491                 if err := pcall(func() {
22492                         ((*(*(struct {
22493                                 Param0 Content
22494
22495                                 Name   string
22496                                 Groups []Group
22497
22498                                 P1Type   Param1Type
22499                                 P2Type   Param2Type
22500                                 DrawType DrawType
22501
22502                                 Mesh  string
22503                                 Scale float32
22504                                 //mt:const uint8(6)
22505                                 Tiles        [6]TileDef
22506                                 OverlayTiles [6]TileDef
22507                                 //mt:const uint8(6)
22508                                 SpecialTiles [6]TileDef
22509
22510                                 Color   color.NRGBA
22511                                 Palette Texture
22512
22513                                 Waving       WaveType
22514                                 ConnectSides uint8
22515                                 ConnectTo    []Content
22516                                 InsideTint   color.NRGBA
22517                                 Level        uint8 // Must be < 128.
22518
22519                                 Translucent bool // Sunlight is scattered and becomes normal light.
22520                                 Transparent bool // Sunlight isn't scattered.
22521                                 LightSrc    uint8
22522
22523                                 GndContent   bool
22524                                 Collides     bool
22525                                 Pointable    bool
22526                                 Diggable     bool
22527                                 Climbable    bool
22528                                 Replaceable  bool
22529                                 OnRightClick bool
22530
22531                                 DmgPerSec int32
22532
22533                                 LiquidType   LiquidType
22534                                 FlowingAlt   string
22535                                 SrcAlt       string
22536                                 Viscosity    uint8 // 0-7
22537                                 LiqRenewable bool
22538                                 FlowRange    uint8
22539                                 DrownDmg     uint8
22540                                 Floodable    bool
22541
22542                                 DrawBox, ColBox, SelBox NodeBox
22543
22544                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22545
22546                                 LegacyFaceDir bool
22547                                 LegacyMounted bool
22548
22549                                 DigPredict string
22550
22551                                 MaxLvl uint8
22552
22553                                 AlphaUse
22554
22555                                 MoveResistance uint8
22556
22557                                 LiquidMovePhysics bool
22558                         }))(obj)).DrawBox).Deserialize(r)
22559                 }); err != nil {
22560                         if err == io.EOF {
22561                                 chk(io.EOF)
22562                         }
22563                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22564                 }
22565                 if err := pcall(func() {
22566                         ((*(*(struct {
22567                                 Param0 Content
22568
22569                                 Name   string
22570                                 Groups []Group
22571
22572                                 P1Type   Param1Type
22573                                 P2Type   Param2Type
22574                                 DrawType DrawType
22575
22576                                 Mesh  string
22577                                 Scale float32
22578                                 //mt:const uint8(6)
22579                                 Tiles        [6]TileDef
22580                                 OverlayTiles [6]TileDef
22581                                 //mt:const uint8(6)
22582                                 SpecialTiles [6]TileDef
22583
22584                                 Color   color.NRGBA
22585                                 Palette Texture
22586
22587                                 Waving       WaveType
22588                                 ConnectSides uint8
22589                                 ConnectTo    []Content
22590                                 InsideTint   color.NRGBA
22591                                 Level        uint8 // Must be < 128.
22592
22593                                 Translucent bool // Sunlight is scattered and becomes normal light.
22594                                 Transparent bool // Sunlight isn't scattered.
22595                                 LightSrc    uint8
22596
22597                                 GndContent   bool
22598                                 Collides     bool
22599                                 Pointable    bool
22600                                 Diggable     bool
22601                                 Climbable    bool
22602                                 Replaceable  bool
22603                                 OnRightClick bool
22604
22605                                 DmgPerSec int32
22606
22607                                 LiquidType   LiquidType
22608                                 FlowingAlt   string
22609                                 SrcAlt       string
22610                                 Viscosity    uint8 // 0-7
22611                                 LiqRenewable bool
22612                                 FlowRange    uint8
22613                                 DrownDmg     uint8
22614                                 Floodable    bool
22615
22616                                 DrawBox, ColBox, SelBox NodeBox
22617
22618                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22619
22620                                 LegacyFaceDir bool
22621                                 LegacyMounted bool
22622
22623                                 DigPredict string
22624
22625                                 MaxLvl uint8
22626
22627                                 AlphaUse
22628
22629                                 MoveResistance uint8
22630
22631                                 LiquidMovePhysics bool
22632                         }))(obj)).ColBox).Deserialize(r)
22633                 }); err != nil {
22634                         if err == io.EOF {
22635                                 chk(io.EOF)
22636                         }
22637                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22638                 }
22639                 if err := pcall(func() {
22640                         ((*(*(struct {
22641                                 Param0 Content
22642
22643                                 Name   string
22644                                 Groups []Group
22645
22646                                 P1Type   Param1Type
22647                                 P2Type   Param2Type
22648                                 DrawType DrawType
22649
22650                                 Mesh  string
22651                                 Scale float32
22652                                 //mt:const uint8(6)
22653                                 Tiles        [6]TileDef
22654                                 OverlayTiles [6]TileDef
22655                                 //mt:const uint8(6)
22656                                 SpecialTiles [6]TileDef
22657
22658                                 Color   color.NRGBA
22659                                 Palette Texture
22660
22661                                 Waving       WaveType
22662                                 ConnectSides uint8
22663                                 ConnectTo    []Content
22664                                 InsideTint   color.NRGBA
22665                                 Level        uint8 // Must be < 128.
22666
22667                                 Translucent bool // Sunlight is scattered and becomes normal light.
22668                                 Transparent bool // Sunlight isn't scattered.
22669                                 LightSrc    uint8
22670
22671                                 GndContent   bool
22672                                 Collides     bool
22673                                 Pointable    bool
22674                                 Diggable     bool
22675                                 Climbable    bool
22676                                 Replaceable  bool
22677                                 OnRightClick bool
22678
22679                                 DmgPerSec int32
22680
22681                                 LiquidType   LiquidType
22682                                 FlowingAlt   string
22683                                 SrcAlt       string
22684                                 Viscosity    uint8 // 0-7
22685                                 LiqRenewable bool
22686                                 FlowRange    uint8
22687                                 DrownDmg     uint8
22688                                 Floodable    bool
22689
22690                                 DrawBox, ColBox, SelBox NodeBox
22691
22692                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22693
22694                                 LegacyFaceDir bool
22695                                 LegacyMounted bool
22696
22697                                 DigPredict string
22698
22699                                 MaxLvl uint8
22700
22701                                 AlphaUse
22702
22703                                 MoveResistance uint8
22704
22705                                 LiquidMovePhysics bool
22706                         }))(obj)).SelBox).Deserialize(r)
22707                 }); err != nil {
22708                         if err == io.EOF {
22709                                 chk(io.EOF)
22710                         }
22711                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22712                 }
22713                 if err := pcall(func() {
22714                         ((*(*(struct {
22715                                 Param0 Content
22716
22717                                 Name   string
22718                                 Groups []Group
22719
22720                                 P1Type   Param1Type
22721                                 P2Type   Param2Type
22722                                 DrawType DrawType
22723
22724                                 Mesh  string
22725                                 Scale float32
22726                                 //mt:const uint8(6)
22727                                 Tiles        [6]TileDef
22728                                 OverlayTiles [6]TileDef
22729                                 //mt:const uint8(6)
22730                                 SpecialTiles [6]TileDef
22731
22732                                 Color   color.NRGBA
22733                                 Palette Texture
22734
22735                                 Waving       WaveType
22736                                 ConnectSides uint8
22737                                 ConnectTo    []Content
22738                                 InsideTint   color.NRGBA
22739                                 Level        uint8 // Must be < 128.
22740
22741                                 Translucent bool // Sunlight is scattered and becomes normal light.
22742                                 Transparent bool // Sunlight isn't scattered.
22743                                 LightSrc    uint8
22744
22745                                 GndContent   bool
22746                                 Collides     bool
22747                                 Pointable    bool
22748                                 Diggable     bool
22749                                 Climbable    bool
22750                                 Replaceable  bool
22751                                 OnRightClick bool
22752
22753                                 DmgPerSec int32
22754
22755                                 LiquidType   LiquidType
22756                                 FlowingAlt   string
22757                                 SrcAlt       string
22758                                 Viscosity    uint8 // 0-7
22759                                 LiqRenewable bool
22760                                 FlowRange    uint8
22761                                 DrownDmg     uint8
22762                                 Floodable    bool
22763
22764                                 DrawBox, ColBox, SelBox NodeBox
22765
22766                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22767
22768                                 LegacyFaceDir bool
22769                                 LegacyMounted bool
22770
22771                                 DigPredict string
22772
22773                                 MaxLvl uint8
22774
22775                                 AlphaUse
22776
22777                                 MoveResistance uint8
22778
22779                                 LiquidMovePhysics bool
22780                         }))(obj)).FootstepSnd).Deserialize(r)
22781                 }); err != nil {
22782                         if err == io.EOF {
22783                                 chk(io.EOF)
22784                         }
22785                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22786                 }
22787                 if err := pcall(func() {
22788                         ((*(*(struct {
22789                                 Param0 Content
22790
22791                                 Name   string
22792                                 Groups []Group
22793
22794                                 P1Type   Param1Type
22795                                 P2Type   Param2Type
22796                                 DrawType DrawType
22797
22798                                 Mesh  string
22799                                 Scale float32
22800                                 //mt:const uint8(6)
22801                                 Tiles        [6]TileDef
22802                                 OverlayTiles [6]TileDef
22803                                 //mt:const uint8(6)
22804                                 SpecialTiles [6]TileDef
22805
22806                                 Color   color.NRGBA
22807                                 Palette Texture
22808
22809                                 Waving       WaveType
22810                                 ConnectSides uint8
22811                                 ConnectTo    []Content
22812                                 InsideTint   color.NRGBA
22813                                 Level        uint8 // Must be < 128.
22814
22815                                 Translucent bool // Sunlight is scattered and becomes normal light.
22816                                 Transparent bool // Sunlight isn't scattered.
22817                                 LightSrc    uint8
22818
22819                                 GndContent   bool
22820                                 Collides     bool
22821                                 Pointable    bool
22822                                 Diggable     bool
22823                                 Climbable    bool
22824                                 Replaceable  bool
22825                                 OnRightClick bool
22826
22827                                 DmgPerSec int32
22828
22829                                 LiquidType   LiquidType
22830                                 FlowingAlt   string
22831                                 SrcAlt       string
22832                                 Viscosity    uint8 // 0-7
22833                                 LiqRenewable bool
22834                                 FlowRange    uint8
22835                                 DrownDmg     uint8
22836                                 Floodable    bool
22837
22838                                 DrawBox, ColBox, SelBox NodeBox
22839
22840                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22841
22842                                 LegacyFaceDir bool
22843                                 LegacyMounted bool
22844
22845                                 DigPredict string
22846
22847                                 MaxLvl uint8
22848
22849                                 AlphaUse
22850
22851                                 MoveResistance uint8
22852
22853                                 LiquidMovePhysics bool
22854                         }))(obj)).DiggingSnd).Deserialize(r)
22855                 }); err != nil {
22856                         if err == io.EOF {
22857                                 chk(io.EOF)
22858                         }
22859                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22860                 }
22861                 if err := pcall(func() {
22862                         ((*(*(struct {
22863                                 Param0 Content
22864
22865                                 Name   string
22866                                 Groups []Group
22867
22868                                 P1Type   Param1Type
22869                                 P2Type   Param2Type
22870                                 DrawType DrawType
22871
22872                                 Mesh  string
22873                                 Scale float32
22874                                 //mt:const uint8(6)
22875                                 Tiles        [6]TileDef
22876                                 OverlayTiles [6]TileDef
22877                                 //mt:const uint8(6)
22878                                 SpecialTiles [6]TileDef
22879
22880                                 Color   color.NRGBA
22881                                 Palette Texture
22882
22883                                 Waving       WaveType
22884                                 ConnectSides uint8
22885                                 ConnectTo    []Content
22886                                 InsideTint   color.NRGBA
22887                                 Level        uint8 // Must be < 128.
22888
22889                                 Translucent bool // Sunlight is scattered and becomes normal light.
22890                                 Transparent bool // Sunlight isn't scattered.
22891                                 LightSrc    uint8
22892
22893                                 GndContent   bool
22894                                 Collides     bool
22895                                 Pointable    bool
22896                                 Diggable     bool
22897                                 Climbable    bool
22898                                 Replaceable  bool
22899                                 OnRightClick bool
22900
22901                                 DmgPerSec int32
22902
22903                                 LiquidType   LiquidType
22904                                 FlowingAlt   string
22905                                 SrcAlt       string
22906                                 Viscosity    uint8 // 0-7
22907                                 LiqRenewable bool
22908                                 FlowRange    uint8
22909                                 DrownDmg     uint8
22910                                 Floodable    bool
22911
22912                                 DrawBox, ColBox, SelBox NodeBox
22913
22914                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22915
22916                                 LegacyFaceDir bool
22917                                 LegacyMounted bool
22918
22919                                 DigPredict string
22920
22921                                 MaxLvl uint8
22922
22923                                 AlphaUse
22924
22925                                 MoveResistance uint8
22926
22927                                 LiquidMovePhysics bool
22928                         }))(obj)).DugSnd).Deserialize(r)
22929                 }); err != nil {
22930                         if err == io.EOF {
22931                                 chk(io.EOF)
22932                         }
22933                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22934                 }
22935                 {
22936                         p := &(*(*(struct {
22937                                 Param0 Content
22938
22939                                 Name   string
22940                                 Groups []Group
22941
22942                                 P1Type   Param1Type
22943                                 P2Type   Param2Type
22944                                 DrawType DrawType
22945
22946                                 Mesh  string
22947                                 Scale float32
22948                                 //mt:const uint8(6)
22949                                 Tiles        [6]TileDef
22950                                 OverlayTiles [6]TileDef
22951                                 //mt:const uint8(6)
22952                                 SpecialTiles [6]TileDef
22953
22954                                 Color   color.NRGBA
22955                                 Palette Texture
22956
22957                                 Waving       WaveType
22958                                 ConnectSides uint8
22959                                 ConnectTo    []Content
22960                                 InsideTint   color.NRGBA
22961                                 Level        uint8 // Must be < 128.
22962
22963                                 Translucent bool // Sunlight is scattered and becomes normal light.
22964                                 Transparent bool // Sunlight isn't scattered.
22965                                 LightSrc    uint8
22966
22967                                 GndContent   bool
22968                                 Collides     bool
22969                                 Pointable    bool
22970                                 Diggable     bool
22971                                 Climbable    bool
22972                                 Replaceable  bool
22973                                 OnRightClick bool
22974
22975                                 DmgPerSec int32
22976
22977                                 LiquidType   LiquidType
22978                                 FlowingAlt   string
22979                                 SrcAlt       string
22980                                 Viscosity    uint8 // 0-7
22981                                 LiqRenewable bool
22982                                 FlowRange    uint8
22983                                 DrownDmg     uint8
22984                                 Floodable    bool
22985
22986                                 DrawBox, ColBox, SelBox NodeBox
22987
22988                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22989
22990                                 LegacyFaceDir bool
22991                                 LegacyMounted bool
22992
22993                                 DigPredict string
22994
22995                                 MaxLvl uint8
22996
22997                                 AlphaUse
22998
22999                                 MoveResistance uint8
23000
23001                                 LiquidMovePhysics bool
23002                         }))(obj)).LegacyFaceDir
23003                         switch n := read8(r); n {
23004                         case 0:
23005                                 *p = false
23006                         case 1:
23007                                 *p = true
23008                         default:
23009                                 chk(fmt.Errorf("invalid bool: %d", n))
23010                         }
23011                 }
23012                 {
23013                         p := &(*(*(struct {
23014                                 Param0 Content
23015
23016                                 Name   string
23017                                 Groups []Group
23018
23019                                 P1Type   Param1Type
23020                                 P2Type   Param2Type
23021                                 DrawType DrawType
23022
23023                                 Mesh  string
23024                                 Scale float32
23025                                 //mt:const uint8(6)
23026                                 Tiles        [6]TileDef
23027                                 OverlayTiles [6]TileDef
23028                                 //mt:const uint8(6)
23029                                 SpecialTiles [6]TileDef
23030
23031                                 Color   color.NRGBA
23032                                 Palette Texture
23033
23034                                 Waving       WaveType
23035                                 ConnectSides uint8
23036                                 ConnectTo    []Content
23037                                 InsideTint   color.NRGBA
23038                                 Level        uint8 // Must be < 128.
23039
23040                                 Translucent bool // Sunlight is scattered and becomes normal light.
23041                                 Transparent bool // Sunlight isn't scattered.
23042                                 LightSrc    uint8
23043
23044                                 GndContent   bool
23045                                 Collides     bool
23046                                 Pointable    bool
23047                                 Diggable     bool
23048                                 Climbable    bool
23049                                 Replaceable  bool
23050                                 OnRightClick bool
23051
23052                                 DmgPerSec int32
23053
23054                                 LiquidType   LiquidType
23055                                 FlowingAlt   string
23056                                 SrcAlt       string
23057                                 Viscosity    uint8 // 0-7
23058                                 LiqRenewable bool
23059                                 FlowRange    uint8
23060                                 DrownDmg     uint8
23061                                 Floodable    bool
23062
23063                                 DrawBox, ColBox, SelBox NodeBox
23064
23065                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23066
23067                                 LegacyFaceDir bool
23068                                 LegacyMounted bool
23069
23070                                 DigPredict string
23071
23072                                 MaxLvl uint8
23073
23074                                 AlphaUse
23075
23076                                 MoveResistance uint8
23077
23078                                 LiquidMovePhysics bool
23079                         }))(obj)).LegacyMounted
23080                         switch n := read8(r); n {
23081                         case 0:
23082                                 *p = false
23083                         case 1:
23084                                 *p = true
23085                         default:
23086                                 chk(fmt.Errorf("invalid bool: %d", n))
23087                         }
23088                 }
23089                 var local267 []uint8
23090                 var local268 uint16
23091                 {
23092                         p := &local268
23093                         *p = read16(r)
23094                 }
23095                 (local267) = make([]uint8, local268)
23096                 {
23097                         _, err := io.ReadFull(r, (local267)[:])
23098                         chk(err)
23099                 }
23100                 ((*(*(struct {
23101                         Param0 Content
23102
23103                         Name   string
23104                         Groups []Group
23105
23106                         P1Type   Param1Type
23107                         P2Type   Param2Type
23108                         DrawType DrawType
23109
23110                         Mesh  string
23111                         Scale float32
23112                         //mt:const uint8(6)
23113                         Tiles        [6]TileDef
23114                         OverlayTiles [6]TileDef
23115                         //mt:const uint8(6)
23116                         SpecialTiles [6]TileDef
23117
23118                         Color   color.NRGBA
23119                         Palette Texture
23120
23121                         Waving       WaveType
23122                         ConnectSides uint8
23123                         ConnectTo    []Content
23124                         InsideTint   color.NRGBA
23125                         Level        uint8 // Must be < 128.
23126
23127                         Translucent bool // Sunlight is scattered and becomes normal light.
23128                         Transparent bool // Sunlight isn't scattered.
23129                         LightSrc    uint8
23130
23131                         GndContent   bool
23132                         Collides     bool
23133                         Pointable    bool
23134                         Diggable     bool
23135                         Climbable    bool
23136                         Replaceable  bool
23137                         OnRightClick bool
23138
23139                         DmgPerSec int32
23140
23141                         LiquidType   LiquidType
23142                         FlowingAlt   string
23143                         SrcAlt       string
23144                         Viscosity    uint8 // 0-7
23145                         LiqRenewable bool
23146                         FlowRange    uint8
23147                         DrownDmg     uint8
23148                         Floodable    bool
23149
23150                         DrawBox, ColBox, SelBox NodeBox
23151
23152                         FootstepSnd, DiggingSnd, DugSnd SoundDef
23153
23154                         LegacyFaceDir bool
23155                         LegacyMounted bool
23156
23157                         DigPredict string
23158
23159                         MaxLvl uint8
23160
23161                         AlphaUse
23162
23163                         MoveResistance uint8
23164
23165                         LiquidMovePhysics bool
23166                 }))(obj)).DigPredict) = string(local267)
23167                 {
23168                         p := &(*(*(struct {
23169                                 Param0 Content
23170
23171                                 Name   string
23172                                 Groups []Group
23173
23174                                 P1Type   Param1Type
23175                                 P2Type   Param2Type
23176                                 DrawType DrawType
23177
23178                                 Mesh  string
23179                                 Scale float32
23180                                 //mt:const uint8(6)
23181                                 Tiles        [6]TileDef
23182                                 OverlayTiles [6]TileDef
23183                                 //mt:const uint8(6)
23184                                 SpecialTiles [6]TileDef
23185
23186                                 Color   color.NRGBA
23187                                 Palette Texture
23188
23189                                 Waving       WaveType
23190                                 ConnectSides uint8
23191                                 ConnectTo    []Content
23192                                 InsideTint   color.NRGBA
23193                                 Level        uint8 // Must be < 128.
23194
23195                                 Translucent bool // Sunlight is scattered and becomes normal light.
23196                                 Transparent bool // Sunlight isn't scattered.
23197                                 LightSrc    uint8
23198
23199                                 GndContent   bool
23200                                 Collides     bool
23201                                 Pointable    bool
23202                                 Diggable     bool
23203                                 Climbable    bool
23204                                 Replaceable  bool
23205                                 OnRightClick bool
23206
23207                                 DmgPerSec int32
23208
23209                                 LiquidType   LiquidType
23210                                 FlowingAlt   string
23211                                 SrcAlt       string
23212                                 Viscosity    uint8 // 0-7
23213                                 LiqRenewable bool
23214                                 FlowRange    uint8
23215                                 DrownDmg     uint8
23216                                 Floodable    bool
23217
23218                                 DrawBox, ColBox, SelBox NodeBox
23219
23220                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23221
23222                                 LegacyFaceDir bool
23223                                 LegacyMounted bool
23224
23225                                 DigPredict string
23226
23227                                 MaxLvl uint8
23228
23229                                 AlphaUse
23230
23231                                 MoveResistance uint8
23232
23233                                 LiquidMovePhysics bool
23234                         }))(obj)).MaxLvl
23235                         *p = read8(r)
23236                 }
23237                 if err := pcall(func() {
23238                         ((*(*(struct {
23239                                 Param0 Content
23240
23241                                 Name   string
23242                                 Groups []Group
23243
23244                                 P1Type   Param1Type
23245                                 P2Type   Param2Type
23246                                 DrawType DrawType
23247
23248                                 Mesh  string
23249                                 Scale float32
23250                                 //mt:const uint8(6)
23251                                 Tiles        [6]TileDef
23252                                 OverlayTiles [6]TileDef
23253                                 //mt:const uint8(6)
23254                                 SpecialTiles [6]TileDef
23255
23256                                 Color   color.NRGBA
23257                                 Palette Texture
23258
23259                                 Waving       WaveType
23260                                 ConnectSides uint8
23261                                 ConnectTo    []Content
23262                                 InsideTint   color.NRGBA
23263                                 Level        uint8 // Must be < 128.
23264
23265                                 Translucent bool // Sunlight is scattered and becomes normal light.
23266                                 Transparent bool // Sunlight isn't scattered.
23267                                 LightSrc    uint8
23268
23269                                 GndContent   bool
23270                                 Collides     bool
23271                                 Pointable    bool
23272                                 Diggable     bool
23273                                 Climbable    bool
23274                                 Replaceable  bool
23275                                 OnRightClick bool
23276
23277                                 DmgPerSec int32
23278
23279                                 LiquidType   LiquidType
23280                                 FlowingAlt   string
23281                                 SrcAlt       string
23282                                 Viscosity    uint8 // 0-7
23283                                 LiqRenewable bool
23284                                 FlowRange    uint8
23285                                 DrownDmg     uint8
23286                                 Floodable    bool
23287
23288                                 DrawBox, ColBox, SelBox NodeBox
23289
23290                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23291
23292                                 LegacyFaceDir bool
23293                                 LegacyMounted bool
23294
23295                                 DigPredict string
23296
23297                                 MaxLvl uint8
23298
23299                                 AlphaUse
23300
23301                                 MoveResistance uint8
23302
23303                                 LiquidMovePhysics bool
23304                         }))(obj)).AlphaUse).Deserialize(r)
23305                 }); err != nil {
23306                         if err == io.EOF {
23307                                 chk(io.EOF)
23308                         }
23309                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlphaUse", err))
23310                 }
23311                 {
23312                         p := &(*(*(struct {
23313                                 Param0 Content
23314
23315                                 Name   string
23316                                 Groups []Group
23317
23318                                 P1Type   Param1Type
23319                                 P2Type   Param2Type
23320                                 DrawType DrawType
23321
23322                                 Mesh  string
23323                                 Scale float32
23324                                 //mt:const uint8(6)
23325                                 Tiles        [6]TileDef
23326                                 OverlayTiles [6]TileDef
23327                                 //mt:const uint8(6)
23328                                 SpecialTiles [6]TileDef
23329
23330                                 Color   color.NRGBA
23331                                 Palette Texture
23332
23333                                 Waving       WaveType
23334                                 ConnectSides uint8
23335                                 ConnectTo    []Content
23336                                 InsideTint   color.NRGBA
23337                                 Level        uint8 // Must be < 128.
23338
23339                                 Translucent bool // Sunlight is scattered and becomes normal light.
23340                                 Transparent bool // Sunlight isn't scattered.
23341                                 LightSrc    uint8
23342
23343                                 GndContent   bool
23344                                 Collides     bool
23345                                 Pointable    bool
23346                                 Diggable     bool
23347                                 Climbable    bool
23348                                 Replaceable  bool
23349                                 OnRightClick bool
23350
23351                                 DmgPerSec int32
23352
23353                                 LiquidType   LiquidType
23354                                 FlowingAlt   string
23355                                 SrcAlt       string
23356                                 Viscosity    uint8 // 0-7
23357                                 LiqRenewable bool
23358                                 FlowRange    uint8
23359                                 DrownDmg     uint8
23360                                 Floodable    bool
23361
23362                                 DrawBox, ColBox, SelBox NodeBox
23363
23364                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23365
23366                                 LegacyFaceDir bool
23367                                 LegacyMounted bool
23368
23369                                 DigPredict string
23370
23371                                 MaxLvl uint8
23372
23373                                 AlphaUse
23374
23375                                 MoveResistance uint8
23376
23377                                 LiquidMovePhysics bool
23378                         }))(obj)).MoveResistance
23379                         *p = read8(r)
23380                 }
23381                 {
23382                         p := &(*(*(struct {
23383                                 Param0 Content
23384
23385                                 Name   string
23386                                 Groups []Group
23387
23388                                 P1Type   Param1Type
23389                                 P2Type   Param2Type
23390                                 DrawType DrawType
23391
23392                                 Mesh  string
23393                                 Scale float32
23394                                 //mt:const uint8(6)
23395                                 Tiles        [6]TileDef
23396                                 OverlayTiles [6]TileDef
23397                                 //mt:const uint8(6)
23398                                 SpecialTiles [6]TileDef
23399
23400                                 Color   color.NRGBA
23401                                 Palette Texture
23402
23403                                 Waving       WaveType
23404                                 ConnectSides uint8
23405                                 ConnectTo    []Content
23406                                 InsideTint   color.NRGBA
23407                                 Level        uint8 // Must be < 128.
23408
23409                                 Translucent bool // Sunlight is scattered and becomes normal light.
23410                                 Transparent bool // Sunlight isn't scattered.
23411                                 LightSrc    uint8
23412
23413                                 GndContent   bool
23414                                 Collides     bool
23415                                 Pointable    bool
23416                                 Diggable     bool
23417                                 Climbable    bool
23418                                 Replaceable  bool
23419                                 OnRightClick bool
23420
23421                                 DmgPerSec int32
23422
23423                                 LiquidType   LiquidType
23424                                 FlowingAlt   string
23425                                 SrcAlt       string
23426                                 Viscosity    uint8 // 0-7
23427                                 LiqRenewable bool
23428                                 FlowRange    uint8
23429                                 DrownDmg     uint8
23430                                 Floodable    bool
23431
23432                                 DrawBox, ColBox, SelBox NodeBox
23433
23434                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23435
23436                                 LegacyFaceDir bool
23437                                 LegacyMounted bool
23438
23439                                 DigPredict string
23440
23441                                 MaxLvl uint8
23442
23443                                 AlphaUse
23444
23445                                 MoveResistance uint8
23446
23447                                 LiquidMovePhysics bool
23448                         }))(obj)).LiquidMovePhysics
23449                         switch n := read8(r); n {
23450                         case 0:
23451                                 *p = false
23452                         case 1:
23453                                 *p = true
23454                         default:
23455                                 chk(fmt.Errorf("invalid bool: %d", n))
23456                         }
23457                 }
23458                 if r.N > 0 {
23459                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23460                 }
23461         }
23462 }
23463
23464 func (obj *PointedNode) Serialize(w io.Writer) {
23465         for local269 := range (*(*(struct {
23466                 Under, Above [3]int16
23467         }))(obj)).Under {
23468                 {
23469                         x := ((*(*(struct {
23470                                 Under, Above [3]int16
23471                         }))(obj)).Under)[local269]
23472                         write16(w, uint16(x))
23473                 }
23474         }
23475         for local270 := range (*(*(struct {
23476                 Under, Above [3]int16
23477         }))(obj)).Above {
23478                 {
23479                         x := ((*(*(struct {
23480                                 Under, Above [3]int16
23481                         }))(obj)).Above)[local270]
23482                         write16(w, uint16(x))
23483                 }
23484         }
23485 }
23486
23487 func (obj *PointedNode) Deserialize(r io.Reader) {
23488         for local271 := range (*(*(struct {
23489                 Under, Above [3]int16
23490         }))(obj)).Under {
23491                 {
23492                         p := &((*(*(struct {
23493                                 Under, Above [3]int16
23494                         }))(obj)).Under)[local271]
23495                         *p = int16(read16(r))
23496                 }
23497         }
23498         for local272 := range (*(*(struct {
23499                 Under, Above [3]int16
23500         }))(obj)).Above {
23501                 {
23502                         p := &((*(*(struct {
23503                                 Under, Above [3]int16
23504                         }))(obj)).Above)[local272]
23505                         *p = int16(read16(r))
23506                 }
23507         }
23508 }
23509
23510 func (obj *PointedAO) Serialize(w io.Writer) {
23511         if err := pcall(func() {
23512                 ((*(*(struct {
23513                         ID AOID
23514                 }))(obj)).ID).Serialize(w)
23515         }); err != nil {
23516                 if err == io.EOF {
23517                         chk(io.EOF)
23518                 }
23519                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23520         }
23521 }
23522
23523 func (obj *PointedAO) Deserialize(r io.Reader) {
23524         if err := pcall(func() {
23525                 ((*(*(struct {
23526                         ID AOID
23527                 }))(obj)).ID).Deserialize(r)
23528         }); err != nil {
23529                 if err == io.EOF {
23530                         chk(io.EOF)
23531                 }
23532                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23533         }
23534 }
23535
23536 func (obj *CompressionModes) Serialize(w io.Writer) {
23537         {
23538                 x := *(*(uint16))(obj)
23539                 write16(w, uint16(x))
23540         }
23541 }
23542
23543 func (obj *CompressionModes) Deserialize(r io.Reader) {
23544         {
23545                 p := &*(*(uint16))(obj)
23546                 *p = read16(r)
23547         }
23548 }
23549
23550 func (obj *PlayerPos) Serialize(w io.Writer) {
23551         for local273 := range (*(*(struct {
23552                 Pos100, Vel100   [3]int32
23553                 Pitch100, Yaw100 int32
23554                 Keys             Keys
23555                 FOV80            uint8
23556                 WantedRange      uint8 // in MapBlks.
23557         }))(obj)).Pos100 {
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)).Pos100)[local273]
23566                         write32(w, uint32(x))
23567                 }
23568         }
23569         for local274 := range (*(*(struct {
23570                 Pos100, Vel100   [3]int32
23571                 Pitch100, Yaw100 int32
23572                 Keys             Keys
23573                 FOV80            uint8
23574                 WantedRange      uint8 // in MapBlks.
23575         }))(obj)).Vel100 {
23576                 {
23577                         x := ((*(*(struct {
23578                                 Pos100, Vel100   [3]int32
23579                                 Pitch100, Yaw100 int32
23580                                 Keys             Keys
23581                                 FOV80            uint8
23582                                 WantedRange      uint8 // in MapBlks.
23583                         }))(obj)).Vel100)[local274]
23584                         write32(w, uint32(x))
23585                 }
23586         }
23587         {
23588                 x := (*(*(struct {
23589                         Pos100, Vel100   [3]int32
23590                         Pitch100, Yaw100 int32
23591                         Keys             Keys
23592                         FOV80            uint8
23593                         WantedRange      uint8 // in MapBlks.
23594                 }))(obj)).Pitch100
23595                 write32(w, uint32(x))
23596         }
23597         {
23598                 x := (*(*(struct {
23599                         Pos100, Vel100   [3]int32
23600                         Pitch100, Yaw100 int32
23601                         Keys             Keys
23602                         FOV80            uint8
23603                         WantedRange      uint8 // in MapBlks.
23604                 }))(obj)).Yaw100
23605                 write32(w, uint32(x))
23606         }
23607         if err := pcall(func() {
23608                 ((*(*(struct {
23609                         Pos100, Vel100   [3]int32
23610                         Pitch100, Yaw100 int32
23611                         Keys             Keys
23612                         FOV80            uint8
23613                         WantedRange      uint8 // in MapBlks.
23614                 }))(obj)).Keys).Serialize(w)
23615         }); err != nil {
23616                 if err == io.EOF {
23617                         chk(io.EOF)
23618                 }
23619                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Keys", err))
23620         }
23621         {
23622                 x := (*(*(struct {
23623                         Pos100, Vel100   [3]int32
23624                         Pitch100, Yaw100 int32
23625                         Keys             Keys
23626                         FOV80            uint8
23627                         WantedRange      uint8 // in MapBlks.
23628                 }))(obj)).FOV80
23629                 write8(w, uint8(x))
23630         }
23631         {
23632                 x := (*(*(struct {
23633                         Pos100, Vel100   [3]int32
23634                         Pitch100, Yaw100 int32
23635                         Keys             Keys
23636                         FOV80            uint8
23637                         WantedRange      uint8 // in MapBlks.
23638                 }))(obj)).WantedRange
23639                 write8(w, uint8(x))
23640         }
23641 }
23642
23643 func (obj *PlayerPos) Deserialize(r io.Reader) {
23644         for local275 := range (*(*(struct {
23645                 Pos100, Vel100   [3]int32
23646                 Pitch100, Yaw100 int32
23647                 Keys             Keys
23648                 FOV80            uint8
23649                 WantedRange      uint8 // in MapBlks.
23650         }))(obj)).Pos100 {
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)).Pos100)[local275]
23659                         *p = int32(read32(r))
23660                 }
23661         }
23662         for local276 := range (*(*(struct {
23663                 Pos100, Vel100   [3]int32
23664                 Pitch100, Yaw100 int32
23665                 Keys             Keys
23666                 FOV80            uint8
23667                 WantedRange      uint8 // in MapBlks.
23668         }))(obj)).Vel100 {
23669                 {
23670                         p := &((*(*(struct {
23671                                 Pos100, Vel100   [3]int32
23672                                 Pitch100, Yaw100 int32
23673                                 Keys             Keys
23674                                 FOV80            uint8
23675                                 WantedRange      uint8 // in MapBlks.
23676                         }))(obj)).Vel100)[local276]
23677                         *p = int32(read32(r))
23678                 }
23679         }
23680         {
23681                 p := &(*(*(struct {
23682                         Pos100, Vel100   [3]int32
23683                         Pitch100, Yaw100 int32
23684                         Keys             Keys
23685                         FOV80            uint8
23686                         WantedRange      uint8 // in MapBlks.
23687                 }))(obj)).Pitch100
23688                 *p = int32(read32(r))
23689         }
23690         {
23691                 p := &(*(*(struct {
23692                         Pos100, Vel100   [3]int32
23693                         Pitch100, Yaw100 int32
23694                         Keys             Keys
23695                         FOV80            uint8
23696                         WantedRange      uint8 // in MapBlks.
23697                 }))(obj)).Yaw100
23698                 *p = int32(read32(r))
23699         }
23700         if err := pcall(func() {
23701                 ((*(*(struct {
23702                         Pos100, Vel100   [3]int32
23703                         Pitch100, Yaw100 int32
23704                         Keys             Keys
23705                         FOV80            uint8
23706                         WantedRange      uint8 // in MapBlks.
23707                 }))(obj)).Keys).Deserialize(r)
23708         }); err != nil {
23709                 if err == io.EOF {
23710                         chk(io.EOF)
23711                 }
23712                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Keys", err))
23713         }
23714         {
23715                 p := &(*(*(struct {
23716                         Pos100, Vel100   [3]int32
23717                         Pitch100, Yaw100 int32
23718                         Keys             Keys
23719                         FOV80            uint8
23720                         WantedRange      uint8 // in MapBlks.
23721                 }))(obj)).FOV80
23722                 *p = read8(r)
23723         }
23724         {
23725                 p := &(*(*(struct {
23726                         Pos100, Vel100   [3]int32
23727                         Pitch100, Yaw100 int32
23728                         Keys             Keys
23729                         FOV80            uint8
23730                         WantedRange      uint8 // in MapBlks.
23731                 }))(obj)).WantedRange
23732                 *p = read8(r)
23733         }
23734 }
23735
23736 func (obj *Interaction) Serialize(w io.Writer) {
23737         {
23738                 x := *(*(uint8))(obj)
23739                 write8(w, uint8(x))
23740         }
23741 }
23742
23743 func (obj *Interaction) Deserialize(r io.Reader) {
23744         {
23745                 p := &*(*(uint8))(obj)
23746                 *p = read8(r)
23747         }
23748 }
23749
23750 func (obj *SoundID) Serialize(w io.Writer) {
23751         {
23752                 x := *(*(int32))(obj)
23753                 write32(w, uint32(x))
23754         }
23755 }
23756
23757 func (obj *SoundID) Deserialize(r io.Reader) {
23758         {
23759                 p := &*(*(int32))(obj)
23760                 *p = int32(read32(r))
23761         }
23762 }
23763
23764 func (obj *Field) Serialize(w io.Writer) {
23765         if len(([]byte((*(*(struct {
23766                 Name string
23767
23768                 //mt:len32
23769                 Value string
23770         }))(obj)).Name))) > math.MaxUint16 {
23771                 chk(ErrTooLong)
23772         }
23773         {
23774                 x := uint16(len(([]byte((*(*(struct {
23775                         Name string
23776
23777                         //mt:len32
23778                         Value string
23779                 }))(obj)).Name))))
23780                 write16(w, uint16(x))
23781         }
23782         {
23783                 _, err := w.Write(([]byte((*(*(struct {
23784                         Name string
23785
23786                         //mt:len32
23787                         Value string
23788                 }))(obj)).Name))[:])
23789                 chk(err)
23790         }
23791         if len(([]byte((*(*(struct {
23792                 Name string
23793
23794                 //mt:len32
23795                 Value string
23796         }))(obj)).Value))) > math.MaxUint32 {
23797                 chk(ErrTooLong)
23798         }
23799         {
23800                 x := uint32(len(([]byte((*(*(struct {
23801                         Name string
23802
23803                         //mt:len32
23804                         Value string
23805                 }))(obj)).Value))))
23806                 write32(w, uint32(x))
23807         }
23808         {
23809                 _, err := w.Write(([]byte((*(*(struct {
23810                         Name string
23811
23812                         //mt:len32
23813                         Value string
23814                 }))(obj)).Value))[:])
23815                 chk(err)
23816         }
23817 }
23818
23819 func (obj *Field) Deserialize(r io.Reader) {
23820         var local277 []uint8
23821         var local278 uint16
23822         {
23823                 p := &local278
23824                 *p = read16(r)
23825         }
23826         (local277) = make([]uint8, local278)
23827         {
23828                 _, err := io.ReadFull(r, (local277)[:])
23829                 chk(err)
23830         }
23831         ((*(*(struct {
23832                 Name string
23833
23834                 //mt:len32
23835                 Value string
23836         }))(obj)).Name) = string(local277)
23837         var local279 []uint8
23838         var local280 uint32
23839         {
23840                 p := &local280
23841                 *p = read32(r)
23842         }
23843         (local279) = make([]uint8, local280)
23844         {
23845                 _, err := io.ReadFull(r, (local279)[:])
23846                 chk(err)
23847         }
23848         ((*(*(struct {
23849                 Name string
23850
23851                 //mt:len32
23852                 Value string
23853         }))(obj)).Value) = string(local279)
23854 }
23855
23856 func (obj *AuthMethods) Serialize(w io.Writer) {
23857         {
23858                 x := *(*(uint32))(obj)
23859                 write32(w, uint32(x))
23860         }
23861 }
23862
23863 func (obj *AuthMethods) Deserialize(r io.Reader) {
23864         {
23865                 p := &*(*(uint32))(obj)
23866                 *p = read32(r)
23867         }
23868 }
23869
23870 func (obj *Pos) Serialize(w io.Writer) {
23871         if err := pcall(func() {
23872                 (*(*(Vec))(obj)).Serialize(w)
23873         }); err != nil {
23874                 if err == io.EOF {
23875                         chk(io.EOF)
23876                 }
23877                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
23878         }
23879 }
23880
23881 func (obj *Pos) Deserialize(r io.Reader) {
23882         if err := pcall(func() {
23883                 (*(*(Vec))(obj)).Deserialize(r)
23884         }); err != nil {
23885                 if err == io.EOF {
23886                         chk(io.EOF)
23887                 }
23888                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
23889         }
23890 }
23891
23892 func (obj *KickReason) Serialize(w io.Writer) {
23893         {
23894                 x := *(*(uint8))(obj)
23895                 write8(w, uint8(x))
23896         }
23897 }
23898
23899 func (obj *KickReason) Deserialize(r io.Reader) {
23900         {
23901                 p := &*(*(uint8))(obj)
23902                 *p = read8(r)
23903         }
23904 }
23905
23906 func (obj *MapBlk) Serialize(w io.Writer) {
23907         if err := pcall(func() {
23908                 ((*(*(struct {
23909                         Flags   MapBlkFlags
23910                         LitFrom LitFromBlks
23911
23912                         Param0 [4096]Content
23913                         Param1 [4096]uint8
23914                         Param2 [4096]uint8
23915
23916                         NodeMetas map[uint16]*NodeMeta
23917                 }))(obj)).Flags).Serialize(w)
23918         }); err != nil {
23919                 if err == io.EOF {
23920                         chk(io.EOF)
23921                 }
23922                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlkFlags", err))
23923         }
23924         if err := pcall(func() {
23925                 ((*(*(struct {
23926                         Flags   MapBlkFlags
23927                         LitFrom LitFromBlks
23928
23929                         Param0 [4096]Content
23930                         Param1 [4096]uint8
23931                         Param2 [4096]uint8
23932
23933                         NodeMetas map[uint16]*NodeMeta
23934                 }))(obj)).LitFrom).Serialize(w)
23935         }); err != nil {
23936                 if err == io.EOF {
23937                         chk(io.EOF)
23938                 }
23939                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LitFromBlks", err))
23940         }
23941         {
23942                 local281 := uint8(2) // Size of param0 in bytes.
23943                 {
23944                         x := local281
23945                         write8(w, uint8(x))
23946                 }
23947         }
23948         {
23949                 local282 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23950                 {
23951                         x := local282
23952                         write8(w, uint8(x))
23953                 }
23954         }
23955         for local283 := range (*(*(struct {
23956                 Flags   MapBlkFlags
23957                 LitFrom LitFromBlks
23958
23959                 Param0 [4096]Content
23960                 Param1 [4096]uint8
23961                 Param2 [4096]uint8
23962
23963                 NodeMetas map[uint16]*NodeMeta
23964         }))(obj)).Param0 {
23965                 if err := pcall(func() {
23966                         (((*(*(struct {
23967                                 Flags   MapBlkFlags
23968                                 LitFrom LitFromBlks
23969
23970                                 Param0 [4096]Content
23971                                 Param1 [4096]uint8
23972                                 Param2 [4096]uint8
23973
23974                                 NodeMetas map[uint16]*NodeMeta
23975                         }))(obj)).Param0)[local283]).Serialize(w)
23976                 }); err != nil {
23977                         if err == io.EOF {
23978                                 chk(io.EOF)
23979                         }
23980                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
23981                 }
23982         }
23983         {
23984                 _, err := w.Write(((*(*(struct {
23985                         Flags   MapBlkFlags
23986                         LitFrom LitFromBlks
23987
23988                         Param0 [4096]Content
23989                         Param1 [4096]uint8
23990                         Param2 [4096]uint8
23991
23992                         NodeMetas map[uint16]*NodeMeta
23993                 }))(obj)).Param1)[:])
23994                 chk(err)
23995         }
23996         {
23997                 _, err := w.Write(((*(*(struct {
23998                         Flags   MapBlkFlags
23999                         LitFrom LitFromBlks
24000
24001                         Param0 [4096]Content
24002                         Param1 [4096]uint8
24003                         Param2 [4096]uint8
24004
24005                         NodeMetas map[uint16]*NodeMeta
24006                 }))(obj)).Param2)[:])
24007                 chk(err)
24008         }
24009         {
24010                 x := (*(*(struct {
24011                         Flags   MapBlkFlags
24012                         LitFrom LitFromBlks
24013
24014                         Param0 [4096]Content
24015                         Param1 [4096]uint8
24016                         Param2 [4096]uint8
24017
24018                         NodeMetas map[uint16]*NodeMeta
24019                 }))(obj)).NodeMetas
24020                 {
24021                         if x == nil {
24022                                 write8(w, 0)
24023                         } else {
24024                                 write8(w, 2)
24025                                 // len(map[uint16]...) always < math.MaxUint16
24026                                 write16(w, uint16(len(x)))
24027                                 keys := make([]uint16, 0, len(x))
24028                                 for key := range x {
24029                                         keys = append(keys, key)
24030                                 }
24031                                 sort.Slice(keys, func(i, j int) bool {
24032                                         i2pos := func(i int) [3]int16 {
24033                                                 return Blkpos2Pos([3]int16{}, keys[i])
24034                                         }
24035                                         p, q := i2pos(i), i2pos(j)
24036                                         for i := range p {
24037                                                 switch {
24038                                                 case p[i] < q[i]:
24039                                                         return true
24040                                                 case p[i] > q[i]:
24041                                                         return false
24042                                                 }
24043                                         }
24044                                         return false
24045                                 })
24046                                 for _, key := range keys {
24047                                         write16(w, key)
24048                                         chk(serialize(w, x[key]))
24049                                 }
24050                         }
24051                 }
24052         }
24053 }
24054
24055 func (obj *MapBlk) Deserialize(r io.Reader) {
24056         if err := pcall(func() {
24057                 ((*(*(struct {
24058                         Flags   MapBlkFlags
24059                         LitFrom LitFromBlks
24060
24061                         Param0 [4096]Content
24062                         Param1 [4096]uint8
24063                         Param2 [4096]uint8
24064
24065                         NodeMetas map[uint16]*NodeMeta
24066                 }))(obj)).Flags).Deserialize(r)
24067         }); err != nil {
24068                 if err == io.EOF {
24069                         chk(io.EOF)
24070                 }
24071                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlkFlags", err))
24072         }
24073         if err := pcall(func() {
24074                 ((*(*(struct {
24075                         Flags   MapBlkFlags
24076                         LitFrom LitFromBlks
24077
24078                         Param0 [4096]Content
24079                         Param1 [4096]uint8
24080                         Param2 [4096]uint8
24081
24082                         NodeMetas map[uint16]*NodeMeta
24083                 }))(obj)).LitFrom).Deserialize(r)
24084         }); err != nil {
24085                 if err == io.EOF {
24086                         chk(io.EOF)
24087                 }
24088                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LitFromBlks", err))
24089         }
24090         {
24091                 var local284 uint8
24092                 local285 := uint8(2) // Size of param0 in bytes.
24093                 {
24094                         p := &local284
24095                         *p = read8(r)
24096                 }
24097                 if local284 != local285 {
24098                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local284))
24099                 }
24100         }
24101         {
24102                 var local286 uint8
24103                 local287 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
24104                 {
24105                         p := &local286
24106                         *p = read8(r)
24107                 }
24108                 if local286 != local287 {
24109                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local286))
24110                 }
24111         }
24112         for local288 := range (*(*(struct {
24113                 Flags   MapBlkFlags
24114                 LitFrom LitFromBlks
24115
24116                 Param0 [4096]Content
24117                 Param1 [4096]uint8
24118                 Param2 [4096]uint8
24119
24120                 NodeMetas map[uint16]*NodeMeta
24121         }))(obj)).Param0 {
24122                 if err := pcall(func() {
24123                         (((*(*(struct {
24124                                 Flags   MapBlkFlags
24125                                 LitFrom LitFromBlks
24126
24127                                 Param0 [4096]Content
24128                                 Param1 [4096]uint8
24129                                 Param2 [4096]uint8
24130
24131                                 NodeMetas map[uint16]*NodeMeta
24132                         }))(obj)).Param0)[local288]).Deserialize(r)
24133                 }); err != nil {
24134                         if err == io.EOF {
24135                                 chk(io.EOF)
24136                         }
24137                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24138                 }
24139         }
24140         {
24141                 _, err := io.ReadFull(r, ((*(*(struct {
24142                         Flags   MapBlkFlags
24143                         LitFrom LitFromBlks
24144
24145                         Param0 [4096]Content
24146                         Param1 [4096]uint8
24147                         Param2 [4096]uint8
24148
24149                         NodeMetas map[uint16]*NodeMeta
24150                 }))(obj)).Param1)[:])
24151                 chk(err)
24152         }
24153         {
24154                 _, err := io.ReadFull(r, ((*(*(struct {
24155                         Flags   MapBlkFlags
24156                         LitFrom LitFromBlks
24157
24158                         Param0 [4096]Content
24159                         Param1 [4096]uint8
24160                         Param2 [4096]uint8
24161
24162                         NodeMetas map[uint16]*NodeMeta
24163                 }))(obj)).Param2)[:])
24164                 chk(err)
24165         }
24166         {
24167                 p := &(*(*(struct {
24168                         Flags   MapBlkFlags
24169                         LitFrom LitFromBlks
24170
24171                         Param0 [4096]Content
24172                         Param1 [4096]uint8
24173                         Param2 [4096]uint8
24174
24175                         NodeMetas map[uint16]*NodeMeta
24176                 }))(obj)).NodeMetas
24177                 {
24178                         switch ver := read8(r); ver {
24179                         case 0:
24180                                 *p = nil
24181                         case 2:
24182                                 n := read16(r)
24183                                 *p = make(map[uint16]*NodeMeta, n)
24184                                 for ; n > 0; n-- {
24185                                         pos := read16(r)
24186                                         nm := new(NodeMeta)
24187                                         chk(deserialize(r, nm))
24188                                         (*p)[pos] = nm
24189                                 }
24190                         default:
24191                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
24192                         }
24193                 }
24194         }
24195 }
24196
24197 func (obj *Node) Serialize(w io.Writer) {
24198         if err := pcall(func() {
24199                 ((*(*(struct {
24200                         Param0         Content
24201                         Param1, Param2 uint8
24202                 }))(obj)).Param0).Serialize(w)
24203         }); err != nil {
24204                 if err == io.EOF {
24205                         chk(io.EOF)
24206                 }
24207                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24208         }
24209         {
24210                 x := (*(*(struct {
24211                         Param0         Content
24212                         Param1, Param2 uint8
24213                 }))(obj)).Param1
24214                 write8(w, uint8(x))
24215         }
24216         {
24217                 x := (*(*(struct {
24218                         Param0         Content
24219                         Param1, Param2 uint8
24220                 }))(obj)).Param2
24221                 write8(w, uint8(x))
24222         }
24223 }
24224
24225 func (obj *Node) Deserialize(r io.Reader) {
24226         if err := pcall(func() {
24227                 ((*(*(struct {
24228                         Param0         Content
24229                         Param1, Param2 uint8
24230                 }))(obj)).Param0).Deserialize(r)
24231         }); err != nil {
24232                 if err == io.EOF {
24233                         chk(io.EOF)
24234                 }
24235                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24236         }
24237         {
24238                 p := &(*(*(struct {
24239                         Param0         Content
24240                         Param1, Param2 uint8
24241                 }))(obj)).Param1
24242                 *p = read8(r)
24243         }
24244         {
24245                 p := &(*(*(struct {
24246                         Param0         Content
24247                         Param1, Param2 uint8
24248                 }))(obj)).Param2
24249                 *p = read8(r)
24250         }
24251 }
24252
24253 func (obj *CSMRestrictionFlags) Serialize(w io.Writer) {
24254         {
24255                 x := *(*(uint64))(obj)
24256                 write64(w, uint64(x))
24257         }
24258 }
24259
24260 func (obj *CSMRestrictionFlags) Deserialize(r io.Reader) {
24261         {
24262                 p := &*(*(uint64))(obj)
24263                 *p = read64(r)
24264         }
24265 }
24266
24267 func (obj *Vec) Serialize(w io.Writer) {
24268         for local289 := range *(*([3]float32))(obj) {
24269                 {
24270                         x := (*(*([3]float32))(obj))[local289]
24271                         write32(w, math.Float32bits(x))
24272                 }
24273         }
24274 }
24275
24276 func (obj *Vec) Deserialize(r io.Reader) {
24277         for local290 := range *(*([3]float32))(obj) {
24278                 {
24279                         p := &(*(*([3]float32))(obj))[local290]
24280                         *p = math.Float32frombits(read32(r))
24281                 }
24282         }
24283 }
24284
24285 func (obj *ChatMsgType) Serialize(w io.Writer) {
24286         {
24287                 x := *(*(uint8))(obj)
24288                 write8(w, uint8(x))
24289         }
24290 }
24291
24292 func (obj *ChatMsgType) Deserialize(r io.Reader) {
24293         {
24294                 p := &*(*(uint8))(obj)
24295                 *p = read8(r)
24296         }
24297 }
24298
24299 func (obj *AOID) Serialize(w io.Writer) {
24300         {
24301                 x := *(*(uint16))(obj)
24302                 write16(w, uint16(x))
24303         }
24304 }
24305
24306 func (obj *AOID) Deserialize(r io.Reader) {
24307         {
24308                 p := &*(*(uint16))(obj)
24309                 *p = read16(r)
24310         }
24311 }
24312
24313 func (obj *AOAdd) Serialize(w io.Writer) {
24314         if err := pcall(func() {
24315                 ((*(*(struct {
24316                         ID AOID
24317                         //mt:const genericCAO
24318                         //mt:lenhdr 32
24319                         InitData AOInitData
24320                 }))(obj)).ID).Serialize(w)
24321         }); err != nil {
24322                 if err == io.EOF {
24323                         chk(io.EOF)
24324                 }
24325                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24326         }
24327         {
24328                 local291 := genericCAO
24329                 if err := pcall(func() {
24330                         (local291).Serialize(w)
24331                 }); err != nil {
24332                         if err == io.EOF {
24333                                 chk(io.EOF)
24334                         }
24335                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
24336                 }
24337         }
24338         {
24339                 ow := w
24340                 w := new(bytes.Buffer)
24341                 if err := pcall(func() {
24342                         ((*(*(struct {
24343                                 ID AOID
24344                                 //mt:const genericCAO
24345                                 //mt:lenhdr 32
24346                                 InitData AOInitData
24347                         }))(obj)).InitData).Serialize(w)
24348                 }); err != nil {
24349                         if err == io.EOF {
24350                                 chk(io.EOF)
24351                         }
24352                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOInitData", err))
24353                 }
24354                 {
24355                         buf := w
24356                         w := ow
24357                         if len((buf.Bytes())) > math.MaxUint32 {
24358                                 chk(ErrTooLong)
24359                         }
24360                         {
24361                                 x := uint32(len((buf.Bytes())))
24362                                 write32(w, uint32(x))
24363                         }
24364                         {
24365                                 _, err := w.Write((buf.Bytes())[:])
24366                                 chk(err)
24367                         }
24368                 }
24369         }
24370 }
24371
24372 func (obj *AOAdd) Deserialize(r io.Reader) {
24373         if err := pcall(func() {
24374                 ((*(*(struct {
24375                         ID AOID
24376                         //mt:const genericCAO
24377                         //mt:lenhdr 32
24378                         InitData AOInitData
24379                 }))(obj)).ID).Deserialize(r)
24380         }); err != nil {
24381                 if err == io.EOF {
24382                         chk(io.EOF)
24383                 }
24384                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24385         }
24386         {
24387                 var local292 aoType
24388                 local293 := genericCAO
24389                 if err := pcall(func() {
24390                         (local292).Deserialize(r)
24391                 }); err != nil {
24392                         if err == io.EOF {
24393                                 chk(io.EOF)
24394                         }
24395                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
24396                 }
24397                 if local292 != local293 {
24398                         chk(fmt.Errorf("const %v: %v", "genericCAO", local292))
24399                 }
24400         }
24401         {
24402                 var n uint32
24403                 {
24404                         p := &n
24405                         *p = read32(r)
24406                 }
24407                 r := &io.LimitedReader{R: r, N: int64(n)}
24408                 if err := pcall(func() {
24409                         ((*(*(struct {
24410                                 ID AOID
24411                                 //mt:const genericCAO
24412                                 //mt:lenhdr 32
24413                                 InitData AOInitData
24414                         }))(obj)).InitData).Deserialize(r)
24415                 }); err != nil {
24416                         if err == io.EOF {
24417                                 chk(io.EOF)
24418                         }
24419                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOInitData", err))
24420                 }
24421                 if r.N > 0 {
24422                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
24423                 }
24424         }
24425 }
24426
24427 func (obj *IDAOMsg) Serialize(w io.Writer) {
24428         if err := pcall(func() {
24429                 ((*(*(struct {
24430                         ID AOID
24431                         //mt:lenhdr 16
24432                         Msg AOMsg
24433                 }))(obj)).ID).Serialize(w)
24434         }); err != nil {
24435                 if err == io.EOF {
24436                         chk(io.EOF)
24437                 }
24438                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24439         }
24440         {
24441                 ow := w
24442                 w := new(bytes.Buffer)
24443                 {
24444                         x := (*(*(struct {
24445                                 ID AOID
24446                                 //mt:lenhdr 16
24447                                 Msg AOMsg
24448                         }))(obj)).Msg
24449                         writeAOMsg(w, x)
24450                 }
24451                 {
24452                         buf := w
24453                         w := ow
24454                         if len((buf.Bytes())) > math.MaxUint16 {
24455                                 chk(ErrTooLong)
24456                         }
24457                         {
24458                                 x := uint16(len((buf.Bytes())))
24459                                 write16(w, uint16(x))
24460                         }
24461                         {
24462                                 _, err := w.Write((buf.Bytes())[:])
24463                                 chk(err)
24464                         }
24465                 }
24466         }
24467 }
24468
24469 func (obj *IDAOMsg) Deserialize(r io.Reader) {
24470         if err := pcall(func() {
24471                 ((*(*(struct {
24472                         ID AOID
24473                         //mt:lenhdr 16
24474                         Msg AOMsg
24475                 }))(obj)).ID).Deserialize(r)
24476         }); err != nil {
24477                 if err == io.EOF {
24478                         chk(io.EOF)
24479                 }
24480                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24481         }
24482         {
24483                 var n uint16
24484                 {
24485                         p := &n
24486                         *p = read16(r)
24487                 }
24488                 r := &io.LimitedReader{R: r, N: int64(n)}
24489                 {
24490                         p := &(*(*(struct {
24491                                 ID AOID
24492                                 //mt:lenhdr 16
24493                                 Msg AOMsg
24494                         }))(obj)).Msg
24495                         {
24496                                 var err error
24497                                 *p, err = readAOMsg(r)
24498                                 chk(err)
24499                         }
24500                 }
24501                 if r.N > 0 {
24502                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
24503                 }
24504         }
24505 }
24506
24507 func (obj *ItemDef) Serialize(w io.Writer) {
24508         {
24509                 ow := w
24510                 w := new(bytes.Buffer)
24511                 {
24512                         local294 := uint8(6)
24513                         {
24514                                 x := local294
24515                                 write8(w, uint8(x))
24516                         }
24517                 }
24518                 if err := pcall(func() {
24519                         ((*(*(struct {
24520                                 Type ItemType
24521
24522                                 Name, Desc string
24523
24524                                 InvImg, WieldImg Texture
24525                                 WieldScale       [3]float32
24526
24527                                 StackMax uint16
24528
24529                                 Usable          bool
24530                                 CanPointLiquids bool
24531
24532                                 ToolCaps ToolCaps
24533
24534                                 Groups []Group
24535
24536                                 PlacePredict string
24537
24538                                 PlaceSnd, PlaceFailSnd SoundDef
24539
24540                                 PointRange float32
24541
24542                                 // Set index in Palette with "palette_index" item meta field,
24543                                 // this overrides Color.
24544                                 Palette Texture
24545                                 Color   color.NRGBA
24546
24547                                 // Texture overlays.
24548                                 InvOverlay, WieldOverlay Texture
24549
24550                                 ShortDesc string
24551
24552                                 PlaceParam2 uint8
24553                         }))(obj)).Type).Serialize(w)
24554                 }); err != nil {
24555                         if err == io.EOF {
24556                                 chk(io.EOF)
24557                         }
24558                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemType", err))
24559                 }
24560                 if len(([]byte((*(*(struct {
24561                         Type ItemType
24562
24563                         Name, Desc string
24564
24565                         InvImg, WieldImg Texture
24566                         WieldScale       [3]float32
24567
24568                         StackMax uint16
24569
24570                         Usable          bool
24571                         CanPointLiquids bool
24572
24573                         ToolCaps ToolCaps
24574
24575                         Groups []Group
24576
24577                         PlacePredict string
24578
24579                         PlaceSnd, PlaceFailSnd SoundDef
24580
24581                         PointRange float32
24582
24583                         // Set index in Palette with "palette_index" item meta field,
24584                         // this overrides Color.
24585                         Palette Texture
24586                         Color   color.NRGBA
24587
24588                         // Texture overlays.
24589                         InvOverlay, WieldOverlay Texture
24590
24591                         ShortDesc string
24592
24593                         PlaceParam2 uint8
24594                 }))(obj)).Name))) > math.MaxUint16 {
24595                         chk(ErrTooLong)
24596                 }
24597                 {
24598                         x := uint16(len(([]byte((*(*(struct {
24599                                 Type ItemType
24600
24601                                 Name, Desc string
24602
24603                                 InvImg, WieldImg Texture
24604                                 WieldScale       [3]float32
24605
24606                                 StackMax uint16
24607
24608                                 Usable          bool
24609                                 CanPointLiquids bool
24610
24611                                 ToolCaps ToolCaps
24612
24613                                 Groups []Group
24614
24615                                 PlacePredict string
24616
24617                                 PlaceSnd, PlaceFailSnd SoundDef
24618
24619                                 PointRange float32
24620
24621                                 // Set index in Palette with "palette_index" item meta field,
24622                                 // this overrides Color.
24623                                 Palette Texture
24624                                 Color   color.NRGBA
24625
24626                                 // Texture overlays.
24627                                 InvOverlay, WieldOverlay Texture
24628
24629                                 ShortDesc string
24630
24631                                 PlaceParam2 uint8
24632                         }))(obj)).Name))))
24633                         write16(w, uint16(x))
24634                 }
24635                 {
24636                         _, err := w.Write(([]byte((*(*(struct {
24637                                 Type ItemType
24638
24639                                 Name, Desc string
24640
24641                                 InvImg, WieldImg Texture
24642                                 WieldScale       [3]float32
24643
24644                                 StackMax uint16
24645
24646                                 Usable          bool
24647                                 CanPointLiquids bool
24648
24649                                 ToolCaps ToolCaps
24650
24651                                 Groups []Group
24652
24653                                 PlacePredict string
24654
24655                                 PlaceSnd, PlaceFailSnd SoundDef
24656
24657                                 PointRange float32
24658
24659                                 // Set index in Palette with "palette_index" item meta field,
24660                                 // this overrides Color.
24661                                 Palette Texture
24662                                 Color   color.NRGBA
24663
24664                                 // Texture overlays.
24665                                 InvOverlay, WieldOverlay Texture
24666
24667                                 ShortDesc string
24668
24669                                 PlaceParam2 uint8
24670                         }))(obj)).Name))[:])
24671                         chk(err)
24672                 }
24673                 if len(([]byte((*(*(struct {
24674                         Type ItemType
24675
24676                         Name, Desc string
24677
24678                         InvImg, WieldImg Texture
24679                         WieldScale       [3]float32
24680
24681                         StackMax uint16
24682
24683                         Usable          bool
24684                         CanPointLiquids bool
24685
24686                         ToolCaps ToolCaps
24687
24688                         Groups []Group
24689
24690                         PlacePredict string
24691
24692                         PlaceSnd, PlaceFailSnd SoundDef
24693
24694                         PointRange float32
24695
24696                         // Set index in Palette with "palette_index" item meta field,
24697                         // this overrides Color.
24698                         Palette Texture
24699                         Color   color.NRGBA
24700
24701                         // Texture overlays.
24702                         InvOverlay, WieldOverlay Texture
24703
24704                         ShortDesc string
24705
24706                         PlaceParam2 uint8
24707                 }))(obj)).Desc))) > math.MaxUint16 {
24708                         chk(ErrTooLong)
24709                 }
24710                 {
24711                         x := uint16(len(([]byte((*(*(struct {
24712                                 Type ItemType
24713
24714                                 Name, Desc string
24715
24716                                 InvImg, WieldImg Texture
24717                                 WieldScale       [3]float32
24718
24719                                 StackMax uint16
24720
24721                                 Usable          bool
24722                                 CanPointLiquids bool
24723
24724                                 ToolCaps ToolCaps
24725
24726                                 Groups []Group
24727
24728                                 PlacePredict string
24729
24730                                 PlaceSnd, PlaceFailSnd SoundDef
24731
24732                                 PointRange float32
24733
24734                                 // Set index in Palette with "palette_index" item meta field,
24735                                 // this overrides Color.
24736                                 Palette Texture
24737                                 Color   color.NRGBA
24738
24739                                 // Texture overlays.
24740                                 InvOverlay, WieldOverlay Texture
24741
24742                                 ShortDesc string
24743
24744                                 PlaceParam2 uint8
24745                         }))(obj)).Desc))))
24746                         write16(w, uint16(x))
24747                 }
24748                 {
24749                         _, err := w.Write(([]byte((*(*(struct {
24750                                 Type ItemType
24751
24752                                 Name, Desc string
24753
24754                                 InvImg, WieldImg Texture
24755                                 WieldScale       [3]float32
24756
24757                                 StackMax uint16
24758
24759                                 Usable          bool
24760                                 CanPointLiquids bool
24761
24762                                 ToolCaps ToolCaps
24763
24764                                 Groups []Group
24765
24766                                 PlacePredict string
24767
24768                                 PlaceSnd, PlaceFailSnd SoundDef
24769
24770                                 PointRange float32
24771
24772                                 // Set index in Palette with "palette_index" item meta field,
24773                                 // this overrides Color.
24774                                 Palette Texture
24775                                 Color   color.NRGBA
24776
24777                                 // Texture overlays.
24778                                 InvOverlay, WieldOverlay Texture
24779
24780                                 ShortDesc string
24781
24782                                 PlaceParam2 uint8
24783                         }))(obj)).Desc))[:])
24784                         chk(err)
24785                 }
24786                 if err := pcall(func() {
24787                         ((*(*(struct {
24788                                 Type ItemType
24789
24790                                 Name, Desc string
24791
24792                                 InvImg, WieldImg Texture
24793                                 WieldScale       [3]float32
24794
24795                                 StackMax uint16
24796
24797                                 Usable          bool
24798                                 CanPointLiquids bool
24799
24800                                 ToolCaps ToolCaps
24801
24802                                 Groups []Group
24803
24804                                 PlacePredict string
24805
24806                                 PlaceSnd, PlaceFailSnd SoundDef
24807
24808                                 PointRange float32
24809
24810                                 // Set index in Palette with "palette_index" item meta field,
24811                                 // this overrides Color.
24812                                 Palette Texture
24813                                 Color   color.NRGBA
24814
24815                                 // Texture overlays.
24816                                 InvOverlay, WieldOverlay Texture
24817
24818                                 ShortDesc string
24819
24820                                 PlaceParam2 uint8
24821                         }))(obj)).InvImg).Serialize(w)
24822                 }); err != nil {
24823                         if err == io.EOF {
24824                                 chk(io.EOF)
24825                         }
24826                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24827                 }
24828                 if err := pcall(func() {
24829                         ((*(*(struct {
24830                                 Type ItemType
24831
24832                                 Name, Desc string
24833
24834                                 InvImg, WieldImg Texture
24835                                 WieldScale       [3]float32
24836
24837                                 StackMax uint16
24838
24839                                 Usable          bool
24840                                 CanPointLiquids bool
24841
24842                                 ToolCaps ToolCaps
24843
24844                                 Groups []Group
24845
24846                                 PlacePredict string
24847
24848                                 PlaceSnd, PlaceFailSnd SoundDef
24849
24850                                 PointRange float32
24851
24852                                 // Set index in Palette with "palette_index" item meta field,
24853                                 // this overrides Color.
24854                                 Palette Texture
24855                                 Color   color.NRGBA
24856
24857                                 // Texture overlays.
24858                                 InvOverlay, WieldOverlay Texture
24859
24860                                 ShortDesc string
24861
24862                                 PlaceParam2 uint8
24863                         }))(obj)).WieldImg).Serialize(w)
24864                 }); err != nil {
24865                         if err == io.EOF {
24866                                 chk(io.EOF)
24867                         }
24868                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24869                 }
24870                 for local295 := range (*(*(struct {
24871                         Type ItemType
24872
24873                         Name, Desc string
24874
24875                         InvImg, WieldImg Texture
24876                         WieldScale       [3]float32
24877
24878                         StackMax uint16
24879
24880                         Usable          bool
24881                         CanPointLiquids bool
24882
24883                         ToolCaps ToolCaps
24884
24885                         Groups []Group
24886
24887                         PlacePredict string
24888
24889                         PlaceSnd, PlaceFailSnd SoundDef
24890
24891                         PointRange float32
24892
24893                         // Set index in Palette with "palette_index" item meta field,
24894                         // this overrides Color.
24895                         Palette Texture
24896                         Color   color.NRGBA
24897
24898                         // Texture overlays.
24899                         InvOverlay, WieldOverlay Texture
24900
24901                         ShortDesc string
24902
24903                         PlaceParam2 uint8
24904                 }))(obj)).WieldScale {
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)).WieldScale)[local295]
24941                                 write32(w, math.Float32bits(x))
24942                         }
24943                 }
24944                 {
24945                         x := (*(*(struct {
24946                                 Type ItemType
24947
24948                                 Name, Desc string
24949
24950                                 InvImg, WieldImg Texture
24951                                 WieldScale       [3]float32
24952
24953                                 StackMax uint16
24954
24955                                 Usable          bool
24956                                 CanPointLiquids bool
24957
24958                                 ToolCaps ToolCaps
24959
24960                                 Groups []Group
24961
24962                                 PlacePredict string
24963
24964                                 PlaceSnd, PlaceFailSnd SoundDef
24965
24966                                 PointRange float32
24967
24968                                 // Set index in Palette with "palette_index" item meta field,
24969                                 // this overrides Color.
24970                                 Palette Texture
24971                                 Color   color.NRGBA
24972
24973                                 // Texture overlays.
24974                                 InvOverlay, WieldOverlay Texture
24975
24976                                 ShortDesc string
24977
24978                                 PlaceParam2 uint8
24979                         }))(obj)).StackMax
24980                         write16(w, uint16(x))
24981                 }
24982                 {
24983                         x := (*(*(struct {
24984                                 Type ItemType
24985
24986                                 Name, Desc string
24987
24988                                 InvImg, WieldImg Texture
24989                                 WieldScale       [3]float32
24990
24991                                 StackMax uint16
24992
24993                                 Usable          bool
24994                                 CanPointLiquids bool
24995
24996                                 ToolCaps ToolCaps
24997
24998                                 Groups []Group
24999
25000                                 PlacePredict string
25001
25002                                 PlaceSnd, PlaceFailSnd SoundDef
25003
25004                                 PointRange float32
25005
25006                                 // Set index in Palette with "palette_index" item meta field,
25007                                 // this overrides Color.
25008                                 Palette Texture
25009                                 Color   color.NRGBA
25010
25011                                 // Texture overlays.
25012                                 InvOverlay, WieldOverlay Texture
25013
25014                                 ShortDesc string
25015
25016                                 PlaceParam2 uint8
25017                         }))(obj)).Usable
25018                         if x {
25019                                 write8(w, 1)
25020                         } else {
25021                                 write8(w, 0)
25022                         }
25023                 }
25024                 {
25025                         x := (*(*(struct {
25026                                 Type ItemType
25027
25028                                 Name, Desc string
25029
25030                                 InvImg, WieldImg Texture
25031                                 WieldScale       [3]float32
25032
25033                                 StackMax uint16
25034
25035                                 Usable          bool
25036                                 CanPointLiquids bool
25037
25038                                 ToolCaps ToolCaps
25039
25040                                 Groups []Group
25041
25042                                 PlacePredict string
25043
25044                                 PlaceSnd, PlaceFailSnd SoundDef
25045
25046                                 PointRange float32
25047
25048                                 // Set index in Palette with "palette_index" item meta field,
25049                                 // this overrides Color.
25050                                 Palette Texture
25051                                 Color   color.NRGBA
25052
25053                                 // Texture overlays.
25054                                 InvOverlay, WieldOverlay Texture
25055
25056                                 ShortDesc string
25057
25058                                 PlaceParam2 uint8
25059                         }))(obj)).CanPointLiquids
25060                         if x {
25061                                 write8(w, 1)
25062                         } else {
25063                                 write8(w, 0)
25064                         }
25065                 }
25066                 if err := pcall(func() {
25067                         ((*(*(struct {
25068                                 Type ItemType
25069
25070                                 Name, Desc string
25071
25072                                 InvImg, WieldImg Texture
25073                                 WieldScale       [3]float32
25074
25075                                 StackMax uint16
25076
25077                                 Usable          bool
25078                                 CanPointLiquids bool
25079
25080                                 ToolCaps ToolCaps
25081
25082                                 Groups []Group
25083
25084                                 PlacePredict string
25085
25086                                 PlaceSnd, PlaceFailSnd SoundDef
25087
25088                                 PointRange float32
25089
25090                                 // Set index in Palette with "palette_index" item meta field,
25091                                 // this overrides Color.
25092                                 Palette Texture
25093                                 Color   color.NRGBA
25094
25095                                 // Texture overlays.
25096                                 InvOverlay, WieldOverlay Texture
25097
25098                                 ShortDesc string
25099
25100                                 PlaceParam2 uint8
25101                         }))(obj)).ToolCaps).Serialize(w)
25102                 }); err != nil {
25103                         if err == io.EOF {
25104                                 chk(io.EOF)
25105                         }
25106                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolCaps", err))
25107                 }
25108                 if len(((*(*(struct {
25109                         Type ItemType
25110
25111                         Name, Desc string
25112
25113                         InvImg, WieldImg Texture
25114                         WieldScale       [3]float32
25115
25116                         StackMax uint16
25117
25118                         Usable          bool
25119                         CanPointLiquids bool
25120
25121                         ToolCaps ToolCaps
25122
25123                         Groups []Group
25124
25125                         PlacePredict string
25126
25127                         PlaceSnd, PlaceFailSnd SoundDef
25128
25129                         PointRange float32
25130
25131                         // Set index in Palette with "palette_index" item meta field,
25132                         // this overrides Color.
25133                         Palette Texture
25134                         Color   color.NRGBA
25135
25136                         // Texture overlays.
25137                         InvOverlay, WieldOverlay Texture
25138
25139                         ShortDesc string
25140
25141                         PlaceParam2 uint8
25142                 }))(obj)).Groups)) > math.MaxUint16 {
25143                         chk(ErrTooLong)
25144                 }
25145                 {
25146                         x := uint16(len(((*(*(struct {
25147                                 Type ItemType
25148
25149                                 Name, Desc string
25150
25151                                 InvImg, WieldImg Texture
25152                                 WieldScale       [3]float32
25153
25154                                 StackMax uint16
25155
25156                                 Usable          bool
25157                                 CanPointLiquids bool
25158
25159                                 ToolCaps ToolCaps
25160
25161                                 Groups []Group
25162
25163                                 PlacePredict string
25164
25165                                 PlaceSnd, PlaceFailSnd SoundDef
25166
25167                                 PointRange float32
25168
25169                                 // Set index in Palette with "palette_index" item meta field,
25170                                 // this overrides Color.
25171                                 Palette Texture
25172                                 Color   color.NRGBA
25173
25174                                 // Texture overlays.
25175                                 InvOverlay, WieldOverlay Texture
25176
25177                                 ShortDesc string
25178
25179                                 PlaceParam2 uint8
25180                         }))(obj)).Groups)))
25181                         write16(w, uint16(x))
25182                 }
25183                 for local296 := range (*(*(struct {
25184                         Type ItemType
25185
25186                         Name, Desc string
25187
25188                         InvImg, WieldImg Texture
25189                         WieldScale       [3]float32
25190
25191                         StackMax uint16
25192
25193                         Usable          bool
25194                         CanPointLiquids bool
25195
25196                         ToolCaps ToolCaps
25197
25198                         Groups []Group
25199
25200                         PlacePredict string
25201
25202                         PlaceSnd, PlaceFailSnd SoundDef
25203
25204                         PointRange float32
25205
25206                         // Set index in Palette with "palette_index" item meta field,
25207                         // this overrides Color.
25208                         Palette Texture
25209                         Color   color.NRGBA
25210
25211                         // Texture overlays.
25212                         InvOverlay, WieldOverlay Texture
25213
25214                         ShortDesc string
25215
25216                         PlaceParam2 uint8
25217                 }))(obj)).Groups {
25218                         if err := pcall(func() {
25219                                 (((*(*(struct {
25220                                         Type ItemType
25221
25222                                         Name, Desc string
25223
25224                                         InvImg, WieldImg Texture
25225                                         WieldScale       [3]float32
25226
25227                                         StackMax uint16
25228
25229                                         Usable          bool
25230                                         CanPointLiquids bool
25231
25232                                         ToolCaps ToolCaps
25233
25234                                         Groups []Group
25235
25236                                         PlacePredict string
25237
25238                                         PlaceSnd, PlaceFailSnd SoundDef
25239
25240                                         PointRange float32
25241
25242                                         // Set index in Palette with "palette_index" item meta field,
25243                                         // this overrides Color.
25244                                         Palette Texture
25245                                         Color   color.NRGBA
25246
25247                                         // Texture overlays.
25248                                         InvOverlay, WieldOverlay Texture
25249
25250                                         ShortDesc string
25251
25252                                         PlaceParam2 uint8
25253                                 }))(obj)).Groups)[local296]).Serialize(w)
25254                         }); err != nil {
25255                                 if err == io.EOF {
25256                                         chk(io.EOF)
25257                                 }
25258                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
25259                         }
25260                 }
25261                 if len(([]byte((*(*(struct {
25262                         Type ItemType
25263
25264                         Name, Desc string
25265
25266                         InvImg, WieldImg Texture
25267                         WieldScale       [3]float32
25268
25269                         StackMax uint16
25270
25271                         Usable          bool
25272                         CanPointLiquids bool
25273
25274                         ToolCaps ToolCaps
25275
25276                         Groups []Group
25277
25278                         PlacePredict string
25279
25280                         PlaceSnd, PlaceFailSnd SoundDef
25281
25282                         PointRange float32
25283
25284                         // Set index in Palette with "palette_index" item meta field,
25285                         // this overrides Color.
25286                         Palette Texture
25287                         Color   color.NRGBA
25288
25289                         // Texture overlays.
25290                         InvOverlay, WieldOverlay Texture
25291
25292                         ShortDesc string
25293
25294                         PlaceParam2 uint8
25295                 }))(obj)).PlacePredict))) > math.MaxUint16 {
25296                         chk(ErrTooLong)
25297                 }
25298                 {
25299                         x := uint16(len(([]byte((*(*(struct {
25300                                 Type ItemType
25301
25302                                 Name, Desc string
25303
25304                                 InvImg, WieldImg Texture
25305                                 WieldScale       [3]float32
25306
25307                                 StackMax uint16
25308
25309                                 Usable          bool
25310                                 CanPointLiquids bool
25311
25312                                 ToolCaps ToolCaps
25313
25314                                 Groups []Group
25315
25316                                 PlacePredict string
25317
25318                                 PlaceSnd, PlaceFailSnd SoundDef
25319
25320                                 PointRange float32
25321
25322                                 // Set index in Palette with "palette_index" item meta field,
25323                                 // this overrides Color.
25324                                 Palette Texture
25325                                 Color   color.NRGBA
25326
25327                                 // Texture overlays.
25328                                 InvOverlay, WieldOverlay Texture
25329
25330                                 ShortDesc string
25331
25332                                 PlaceParam2 uint8
25333                         }))(obj)).PlacePredict))))
25334                         write16(w, uint16(x))
25335                 }
25336                 {
25337                         _, err := w.Write(([]byte((*(*(struct {
25338                                 Type ItemType
25339
25340                                 Name, Desc string
25341
25342                                 InvImg, WieldImg Texture
25343                                 WieldScale       [3]float32
25344
25345                                 StackMax uint16
25346
25347                                 Usable          bool
25348                                 CanPointLiquids bool
25349
25350                                 ToolCaps ToolCaps
25351
25352                                 Groups []Group
25353
25354                                 PlacePredict string
25355
25356                                 PlaceSnd, PlaceFailSnd SoundDef
25357
25358                                 PointRange float32
25359
25360                                 // Set index in Palette with "palette_index" item meta field,
25361                                 // this overrides Color.
25362                                 Palette Texture
25363                                 Color   color.NRGBA
25364
25365                                 // Texture overlays.
25366                                 InvOverlay, WieldOverlay Texture
25367
25368                                 ShortDesc string
25369
25370                                 PlaceParam2 uint8
25371                         }))(obj)).PlacePredict))[:])
25372                         chk(err)
25373                 }
25374                 if err := pcall(func() {
25375                         ((*(*(struct {
25376                                 Type ItemType
25377
25378                                 Name, Desc string
25379
25380                                 InvImg, WieldImg Texture
25381                                 WieldScale       [3]float32
25382
25383                                 StackMax uint16
25384
25385                                 Usable          bool
25386                                 CanPointLiquids bool
25387
25388                                 ToolCaps ToolCaps
25389
25390                                 Groups []Group
25391
25392                                 PlacePredict string
25393
25394                                 PlaceSnd, PlaceFailSnd SoundDef
25395
25396                                 PointRange float32
25397
25398                                 // Set index in Palette with "palette_index" item meta field,
25399                                 // this overrides Color.
25400                                 Palette Texture
25401                                 Color   color.NRGBA
25402
25403                                 // Texture overlays.
25404                                 InvOverlay, WieldOverlay Texture
25405
25406                                 ShortDesc string
25407
25408                                 PlaceParam2 uint8
25409                         }))(obj)).PlaceSnd).Serialize(w)
25410                 }); err != nil {
25411                         if err == io.EOF {
25412                                 chk(io.EOF)
25413                         }
25414                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
25415                 }
25416                 if err := pcall(func() {
25417                         ((*(*(struct {
25418                                 Type ItemType
25419
25420                                 Name, Desc string
25421
25422                                 InvImg, WieldImg Texture
25423                                 WieldScale       [3]float32
25424
25425                                 StackMax uint16
25426
25427                                 Usable          bool
25428                                 CanPointLiquids bool
25429
25430                                 ToolCaps ToolCaps
25431
25432                                 Groups []Group
25433
25434                                 PlacePredict string
25435
25436                                 PlaceSnd, PlaceFailSnd SoundDef
25437
25438                                 PointRange float32
25439
25440                                 // Set index in Palette with "palette_index" item meta field,
25441                                 // this overrides Color.
25442                                 Palette Texture
25443                                 Color   color.NRGBA
25444
25445                                 // Texture overlays.
25446                                 InvOverlay, WieldOverlay Texture
25447
25448                                 ShortDesc string
25449
25450                                 PlaceParam2 uint8
25451                         }))(obj)).PlaceFailSnd).Serialize(w)
25452                 }); err != nil {
25453                         if err == io.EOF {
25454                                 chk(io.EOF)
25455                         }
25456                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
25457                 }
25458                 {
25459                         x := (*(*(struct {
25460                                 Type ItemType
25461
25462                                 Name, Desc string
25463
25464                                 InvImg, WieldImg Texture
25465                                 WieldScale       [3]float32
25466
25467                                 StackMax uint16
25468
25469                                 Usable          bool
25470                                 CanPointLiquids bool
25471
25472                                 ToolCaps ToolCaps
25473
25474                                 Groups []Group
25475
25476                                 PlacePredict string
25477
25478                                 PlaceSnd, PlaceFailSnd SoundDef
25479
25480                                 PointRange float32
25481
25482                                 // Set index in Palette with "palette_index" item meta field,
25483                                 // this overrides Color.
25484                                 Palette Texture
25485                                 Color   color.NRGBA
25486
25487                                 // Texture overlays.
25488                                 InvOverlay, WieldOverlay Texture
25489
25490                                 ShortDesc string
25491
25492                                 PlaceParam2 uint8
25493                         }))(obj)).PointRange
25494                         write32(w, math.Float32bits(x))
25495                 }
25496                 if err := pcall(func() {
25497                         ((*(*(struct {
25498                                 Type ItemType
25499
25500                                 Name, Desc string
25501
25502                                 InvImg, WieldImg Texture
25503                                 WieldScale       [3]float32
25504
25505                                 StackMax uint16
25506
25507                                 Usable          bool
25508                                 CanPointLiquids bool
25509
25510                                 ToolCaps ToolCaps
25511
25512                                 Groups []Group
25513
25514                                 PlacePredict string
25515
25516                                 PlaceSnd, PlaceFailSnd SoundDef
25517
25518                                 PointRange float32
25519
25520                                 // Set index in Palette with "palette_index" item meta field,
25521                                 // this overrides Color.
25522                                 Palette Texture
25523                                 Color   color.NRGBA
25524
25525                                 // Texture overlays.
25526                                 InvOverlay, WieldOverlay Texture
25527
25528                                 ShortDesc string
25529
25530                                 PlaceParam2 uint8
25531                         }))(obj)).Palette).Serialize(w)
25532                 }); err != nil {
25533                         if err == io.EOF {
25534                                 chk(io.EOF)
25535                         }
25536                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25537                 }
25538                 {
25539                         x := (*(*(struct {
25540                                 Type ItemType
25541
25542                                 Name, Desc string
25543
25544                                 InvImg, WieldImg Texture
25545                                 WieldScale       [3]float32
25546
25547                                 StackMax uint16
25548
25549                                 Usable          bool
25550                                 CanPointLiquids bool
25551
25552                                 ToolCaps ToolCaps
25553
25554                                 Groups []Group
25555
25556                                 PlacePredict string
25557
25558                                 PlaceSnd, PlaceFailSnd SoundDef
25559
25560                                 PointRange float32
25561
25562                                 // Set index in Palette with "palette_index" item meta field,
25563                                 // this overrides Color.
25564                                 Palette Texture
25565                                 Color   color.NRGBA
25566
25567                                 // Texture overlays.
25568                                 InvOverlay, WieldOverlay Texture
25569
25570                                 ShortDesc string
25571
25572                                 PlaceParam2 uint8
25573                         }))(obj)).Color
25574                         w.Write([]byte{x.A, x.R, x.G, x.B})
25575                 }
25576                 if err := pcall(func() {
25577                         ((*(*(struct {
25578                                 Type ItemType
25579
25580                                 Name, Desc string
25581
25582                                 InvImg, WieldImg Texture
25583                                 WieldScale       [3]float32
25584
25585                                 StackMax uint16
25586
25587                                 Usable          bool
25588                                 CanPointLiquids bool
25589
25590                                 ToolCaps ToolCaps
25591
25592                                 Groups []Group
25593
25594                                 PlacePredict string
25595
25596                                 PlaceSnd, PlaceFailSnd SoundDef
25597
25598                                 PointRange float32
25599
25600                                 // Set index in Palette with "palette_index" item meta field,
25601                                 // this overrides Color.
25602                                 Palette Texture
25603                                 Color   color.NRGBA
25604
25605                                 // Texture overlays.
25606                                 InvOverlay, WieldOverlay Texture
25607
25608                                 ShortDesc string
25609
25610                                 PlaceParam2 uint8
25611                         }))(obj)).InvOverlay).Serialize(w)
25612                 }); err != nil {
25613                         if err == io.EOF {
25614                                 chk(io.EOF)
25615                         }
25616                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25617                 }
25618                 if err := pcall(func() {
25619                         ((*(*(struct {
25620                                 Type ItemType
25621
25622                                 Name, Desc string
25623
25624                                 InvImg, WieldImg Texture
25625                                 WieldScale       [3]float32
25626
25627                                 StackMax uint16
25628
25629                                 Usable          bool
25630                                 CanPointLiquids bool
25631
25632                                 ToolCaps ToolCaps
25633
25634                                 Groups []Group
25635
25636                                 PlacePredict string
25637
25638                                 PlaceSnd, PlaceFailSnd SoundDef
25639
25640                                 PointRange float32
25641
25642                                 // Set index in Palette with "palette_index" item meta field,
25643                                 // this overrides Color.
25644                                 Palette Texture
25645                                 Color   color.NRGBA
25646
25647                                 // Texture overlays.
25648                                 InvOverlay, WieldOverlay Texture
25649
25650                                 ShortDesc string
25651
25652                                 PlaceParam2 uint8
25653                         }))(obj)).WieldOverlay).Serialize(w)
25654                 }); err != nil {
25655                         if err == io.EOF {
25656                                 chk(io.EOF)
25657                         }
25658                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25659                 }
25660                 if len(([]byte((*(*(struct {
25661                         Type ItemType
25662
25663                         Name, Desc string
25664
25665                         InvImg, WieldImg Texture
25666                         WieldScale       [3]float32
25667
25668                         StackMax uint16
25669
25670                         Usable          bool
25671                         CanPointLiquids bool
25672
25673                         ToolCaps ToolCaps
25674
25675                         Groups []Group
25676
25677                         PlacePredict string
25678
25679                         PlaceSnd, PlaceFailSnd SoundDef
25680
25681                         PointRange float32
25682
25683                         // Set index in Palette with "palette_index" item meta field,
25684                         // this overrides Color.
25685                         Palette Texture
25686                         Color   color.NRGBA
25687
25688                         // Texture overlays.
25689                         InvOverlay, WieldOverlay Texture
25690
25691                         ShortDesc string
25692
25693                         PlaceParam2 uint8
25694                 }))(obj)).ShortDesc))) > math.MaxUint16 {
25695                         chk(ErrTooLong)
25696                 }
25697                 {
25698                         x := uint16(len(([]byte((*(*(struct {
25699                                 Type ItemType
25700
25701                                 Name, Desc string
25702
25703                                 InvImg, WieldImg Texture
25704                                 WieldScale       [3]float32
25705
25706                                 StackMax uint16
25707
25708                                 Usable          bool
25709                                 CanPointLiquids bool
25710
25711                                 ToolCaps ToolCaps
25712
25713                                 Groups []Group
25714
25715                                 PlacePredict string
25716
25717                                 PlaceSnd, PlaceFailSnd SoundDef
25718
25719                                 PointRange float32
25720
25721                                 // Set index in Palette with "palette_index" item meta field,
25722                                 // this overrides Color.
25723                                 Palette Texture
25724                                 Color   color.NRGBA
25725
25726                                 // Texture overlays.
25727                                 InvOverlay, WieldOverlay Texture
25728
25729                                 ShortDesc string
25730
25731                                 PlaceParam2 uint8
25732                         }))(obj)).ShortDesc))))
25733                         write16(w, uint16(x))
25734                 }
25735                 {
25736                         _, err := w.Write(([]byte((*(*(struct {
25737                                 Type ItemType
25738
25739                                 Name, Desc string
25740
25741                                 InvImg, WieldImg Texture
25742                                 WieldScale       [3]float32
25743
25744                                 StackMax uint16
25745
25746                                 Usable          bool
25747                                 CanPointLiquids bool
25748
25749                                 ToolCaps ToolCaps
25750
25751                                 Groups []Group
25752
25753                                 PlacePredict string
25754
25755                                 PlaceSnd, PlaceFailSnd SoundDef
25756
25757                                 PointRange float32
25758
25759                                 // Set index in Palette with "palette_index" item meta field,
25760                                 // this overrides Color.
25761                                 Palette Texture
25762                                 Color   color.NRGBA
25763
25764                                 // Texture overlays.
25765                                 InvOverlay, WieldOverlay Texture
25766
25767                                 ShortDesc string
25768
25769                                 PlaceParam2 uint8
25770                         }))(obj)).ShortDesc))[:])
25771                         chk(err)
25772                 }
25773                 {
25774                         x := (*(*(struct {
25775                                 Type ItemType
25776
25777                                 Name, Desc string
25778
25779                                 InvImg, WieldImg Texture
25780                                 WieldScale       [3]float32
25781
25782                                 StackMax uint16
25783
25784                                 Usable          bool
25785                                 CanPointLiquids bool
25786
25787                                 ToolCaps ToolCaps
25788
25789                                 Groups []Group
25790
25791                                 PlacePredict string
25792
25793                                 PlaceSnd, PlaceFailSnd SoundDef
25794
25795                                 PointRange float32
25796
25797                                 // Set index in Palette with "palette_index" item meta field,
25798                                 // this overrides Color.
25799                                 Palette Texture
25800                                 Color   color.NRGBA
25801
25802                                 // Texture overlays.
25803                                 InvOverlay, WieldOverlay Texture
25804
25805                                 ShortDesc string
25806
25807                                 PlaceParam2 uint8
25808                         }))(obj)).PlaceParam2
25809                         write8(w, uint8(x))
25810                 }
25811                 {
25812                         buf := w
25813                         w := ow
25814                         if len((buf.Bytes())) > math.MaxUint16 {
25815                                 chk(ErrTooLong)
25816                         }
25817                         {
25818                                 x := uint16(len((buf.Bytes())))
25819                                 write16(w, uint16(x))
25820                         }
25821                         {
25822                                 _, err := w.Write((buf.Bytes())[:])
25823                                 chk(err)
25824                         }
25825                 }
25826         }
25827 }
25828
25829 func (obj *ItemDef) Deserialize(r io.Reader) {
25830         {
25831                 var n uint16
25832                 {
25833                         p := &n
25834                         *p = read16(r)
25835                 }
25836                 r := &io.LimitedReader{R: r, N: int64(n)}
25837                 {
25838                         var local297 uint8
25839                         local298 := uint8(6)
25840                         {
25841                                 p := &local297
25842                                 *p = read8(r)
25843                         }
25844                         if local297 != local298 {
25845                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local297))
25846                         }
25847                 }
25848                 if err := pcall(func() {
25849                         ((*(*(struct {
25850                                 Type ItemType
25851
25852                                 Name, Desc string
25853
25854                                 InvImg, WieldImg Texture
25855                                 WieldScale       [3]float32
25856
25857                                 StackMax uint16
25858
25859                                 Usable          bool
25860                                 CanPointLiquids bool
25861
25862                                 ToolCaps ToolCaps
25863
25864                                 Groups []Group
25865
25866                                 PlacePredict string
25867
25868                                 PlaceSnd, PlaceFailSnd SoundDef
25869
25870                                 PointRange float32
25871
25872                                 // Set index in Palette with "palette_index" item meta field,
25873                                 // this overrides Color.
25874                                 Palette Texture
25875                                 Color   color.NRGBA
25876
25877                                 // Texture overlays.
25878                                 InvOverlay, WieldOverlay Texture
25879
25880                                 ShortDesc string
25881
25882                                 PlaceParam2 uint8
25883                         }))(obj)).Type).Deserialize(r)
25884                 }); err != nil {
25885                         if err == io.EOF {
25886                                 chk(io.EOF)
25887                         }
25888                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemType", err))
25889                 }
25890                 var local299 []uint8
25891                 var local300 uint16
25892                 {
25893                         p := &local300
25894                         *p = read16(r)
25895                 }
25896                 (local299) = make([]uint8, local300)
25897                 {
25898                         _, err := io.ReadFull(r, (local299)[:])
25899                         chk(err)
25900                 }
25901                 ((*(*(struct {
25902                         Type ItemType
25903
25904                         Name, Desc string
25905
25906                         InvImg, WieldImg Texture
25907                         WieldScale       [3]float32
25908
25909                         StackMax uint16
25910
25911                         Usable          bool
25912                         CanPointLiquids bool
25913
25914                         ToolCaps ToolCaps
25915
25916                         Groups []Group
25917
25918                         PlacePredict string
25919
25920                         PlaceSnd, PlaceFailSnd SoundDef
25921
25922                         PointRange float32
25923
25924                         // Set index in Palette with "palette_index" item meta field,
25925                         // this overrides Color.
25926                         Palette Texture
25927                         Color   color.NRGBA
25928
25929                         // Texture overlays.
25930                         InvOverlay, WieldOverlay Texture
25931
25932                         ShortDesc string
25933
25934                         PlaceParam2 uint8
25935                 }))(obj)).Name) = string(local299)
25936                 var local301 []uint8
25937                 var local302 uint16
25938                 {
25939                         p := &local302
25940                         *p = read16(r)
25941                 }
25942                 (local301) = make([]uint8, local302)
25943                 {
25944                         _, err := io.ReadFull(r, (local301)[:])
25945                         chk(err)
25946                 }
25947                 ((*(*(struct {
25948                         Type ItemType
25949
25950                         Name, Desc string
25951
25952                         InvImg, WieldImg Texture
25953                         WieldScale       [3]float32
25954
25955                         StackMax uint16
25956
25957                         Usable          bool
25958                         CanPointLiquids bool
25959
25960                         ToolCaps ToolCaps
25961
25962                         Groups []Group
25963
25964                         PlacePredict string
25965
25966                         PlaceSnd, PlaceFailSnd SoundDef
25967
25968                         PointRange float32
25969
25970                         // Set index in Palette with "palette_index" item meta field,
25971                         // this overrides Color.
25972                         Palette Texture
25973                         Color   color.NRGBA
25974
25975                         // Texture overlays.
25976                         InvOverlay, WieldOverlay Texture
25977
25978                         ShortDesc string
25979
25980                         PlaceParam2 uint8
25981                 }))(obj)).Desc) = string(local301)
25982                 if err := pcall(func() {
25983                         ((*(*(struct {
25984                                 Type ItemType
25985
25986                                 Name, Desc string
25987
25988                                 InvImg, WieldImg Texture
25989                                 WieldScale       [3]float32
25990
25991                                 StackMax uint16
25992
25993                                 Usable          bool
25994                                 CanPointLiquids bool
25995
25996                                 ToolCaps ToolCaps
25997
25998                                 Groups []Group
25999
26000                                 PlacePredict string
26001
26002                                 PlaceSnd, PlaceFailSnd SoundDef
26003
26004                                 PointRange float32
26005
26006                                 // Set index in Palette with "palette_index" item meta field,
26007                                 // this overrides Color.
26008                                 Palette Texture
26009                                 Color   color.NRGBA
26010
26011                                 // Texture overlays.
26012                                 InvOverlay, WieldOverlay Texture
26013
26014                                 ShortDesc string
26015
26016                                 PlaceParam2 uint8
26017                         }))(obj)).InvImg).Deserialize(r)
26018                 }); err != nil {
26019                         if err == io.EOF {
26020                                 chk(io.EOF)
26021                         }
26022                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26023                 }
26024                 if err := pcall(func() {
26025                         ((*(*(struct {
26026                                 Type ItemType
26027
26028                                 Name, Desc string
26029
26030                                 InvImg, WieldImg Texture
26031                                 WieldScale       [3]float32
26032
26033                                 StackMax uint16
26034
26035                                 Usable          bool
26036                                 CanPointLiquids bool
26037
26038                                 ToolCaps ToolCaps
26039
26040                                 Groups []Group
26041
26042                                 PlacePredict string
26043
26044                                 PlaceSnd, PlaceFailSnd SoundDef
26045
26046                                 PointRange float32
26047
26048                                 // Set index in Palette with "palette_index" item meta field,
26049                                 // this overrides Color.
26050                                 Palette Texture
26051                                 Color   color.NRGBA
26052
26053                                 // Texture overlays.
26054                                 InvOverlay, WieldOverlay Texture
26055
26056                                 ShortDesc string
26057
26058                                 PlaceParam2 uint8
26059                         }))(obj)).WieldImg).Deserialize(r)
26060                 }); err != nil {
26061                         if err == io.EOF {
26062                                 chk(io.EOF)
26063                         }
26064                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26065                 }
26066                 for local303 := range (*(*(struct {
26067                         Type ItemType
26068
26069                         Name, Desc string
26070
26071                         InvImg, WieldImg Texture
26072                         WieldScale       [3]float32
26073
26074                         StackMax uint16
26075
26076                         Usable          bool
26077                         CanPointLiquids bool
26078
26079                         ToolCaps ToolCaps
26080
26081                         Groups []Group
26082
26083                         PlacePredict string
26084
26085                         PlaceSnd, PlaceFailSnd SoundDef
26086
26087                         PointRange float32
26088
26089                         // Set index in Palette with "palette_index" item meta field,
26090                         // this overrides Color.
26091                         Palette Texture
26092                         Color   color.NRGBA
26093
26094                         // Texture overlays.
26095                         InvOverlay, WieldOverlay Texture
26096
26097                         ShortDesc string
26098
26099                         PlaceParam2 uint8
26100                 }))(obj)).WieldScale {
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)).WieldScale)[local303]
26137                                 *p = math.Float32frombits(read32(r))
26138                         }
26139                 }
26140                 {
26141                         p := &(*(*(struct {
26142                                 Type ItemType
26143
26144                                 Name, Desc string
26145
26146                                 InvImg, WieldImg Texture
26147                                 WieldScale       [3]float32
26148
26149                                 StackMax uint16
26150
26151                                 Usable          bool
26152                                 CanPointLiquids bool
26153
26154                                 ToolCaps ToolCaps
26155
26156                                 Groups []Group
26157
26158                                 PlacePredict string
26159
26160                                 PlaceSnd, PlaceFailSnd SoundDef
26161
26162                                 PointRange float32
26163
26164                                 // Set index in Palette with "palette_index" item meta field,
26165                                 // this overrides Color.
26166                                 Palette Texture
26167                                 Color   color.NRGBA
26168
26169                                 // Texture overlays.
26170                                 InvOverlay, WieldOverlay Texture
26171
26172                                 ShortDesc string
26173
26174                                 PlaceParam2 uint8
26175                         }))(obj)).StackMax
26176                         *p = read16(r)
26177                 }
26178                 {
26179                         p := &(*(*(struct {
26180                                 Type ItemType
26181
26182                                 Name, Desc string
26183
26184                                 InvImg, WieldImg Texture
26185                                 WieldScale       [3]float32
26186
26187                                 StackMax uint16
26188
26189                                 Usable          bool
26190                                 CanPointLiquids bool
26191
26192                                 ToolCaps ToolCaps
26193
26194                                 Groups []Group
26195
26196                                 PlacePredict string
26197
26198                                 PlaceSnd, PlaceFailSnd SoundDef
26199
26200                                 PointRange float32
26201
26202                                 // Set index in Palette with "palette_index" item meta field,
26203                                 // this overrides Color.
26204                                 Palette Texture
26205                                 Color   color.NRGBA
26206
26207                                 // Texture overlays.
26208                                 InvOverlay, WieldOverlay Texture
26209
26210                                 ShortDesc string
26211
26212                                 PlaceParam2 uint8
26213                         }))(obj)).Usable
26214                         switch n := read8(r); n {
26215                         case 0:
26216                                 *p = false
26217                         case 1:
26218                                 *p = true
26219                         default:
26220                                 chk(fmt.Errorf("invalid bool: %d", n))
26221                         }
26222                 }
26223                 {
26224                         p := &(*(*(struct {
26225                                 Type ItemType
26226
26227                                 Name, Desc string
26228
26229                                 InvImg, WieldImg Texture
26230                                 WieldScale       [3]float32
26231
26232                                 StackMax uint16
26233
26234                                 Usable          bool
26235                                 CanPointLiquids bool
26236
26237                                 ToolCaps ToolCaps
26238
26239                                 Groups []Group
26240
26241                                 PlacePredict string
26242
26243                                 PlaceSnd, PlaceFailSnd SoundDef
26244
26245                                 PointRange float32
26246
26247                                 // Set index in Palette with "palette_index" item meta field,
26248                                 // this overrides Color.
26249                                 Palette Texture
26250                                 Color   color.NRGBA
26251
26252                                 // Texture overlays.
26253                                 InvOverlay, WieldOverlay Texture
26254
26255                                 ShortDesc string
26256
26257                                 PlaceParam2 uint8
26258                         }))(obj)).CanPointLiquids
26259                         switch n := read8(r); n {
26260                         case 0:
26261                                 *p = false
26262                         case 1:
26263                                 *p = true
26264                         default:
26265                                 chk(fmt.Errorf("invalid bool: %d", n))
26266                         }
26267                 }
26268                 if err := pcall(func() {
26269                         ((*(*(struct {
26270                                 Type ItemType
26271
26272                                 Name, Desc string
26273
26274                                 InvImg, WieldImg Texture
26275                                 WieldScale       [3]float32
26276
26277                                 StackMax uint16
26278
26279                                 Usable          bool
26280                                 CanPointLiquids bool
26281
26282                                 ToolCaps ToolCaps
26283
26284                                 Groups []Group
26285
26286                                 PlacePredict string
26287
26288                                 PlaceSnd, PlaceFailSnd SoundDef
26289
26290                                 PointRange float32
26291
26292                                 // Set index in Palette with "palette_index" item meta field,
26293                                 // this overrides Color.
26294                                 Palette Texture
26295                                 Color   color.NRGBA
26296
26297                                 // Texture overlays.
26298                                 InvOverlay, WieldOverlay Texture
26299
26300                                 ShortDesc string
26301
26302                                 PlaceParam2 uint8
26303                         }))(obj)).ToolCaps).Deserialize(r)
26304                 }); err != nil {
26305                         if err == io.EOF {
26306                                 chk(io.EOF)
26307                         }
26308                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolCaps", err))
26309                 }
26310                 var local304 uint16
26311                 {
26312                         p := &local304
26313                         *p = read16(r)
26314                 }
26315                 ((*(*(struct {
26316                         Type ItemType
26317
26318                         Name, Desc string
26319
26320                         InvImg, WieldImg Texture
26321                         WieldScale       [3]float32
26322
26323                         StackMax uint16
26324
26325                         Usable          bool
26326                         CanPointLiquids bool
26327
26328                         ToolCaps ToolCaps
26329
26330                         Groups []Group
26331
26332                         PlacePredict string
26333
26334                         PlaceSnd, PlaceFailSnd SoundDef
26335
26336                         PointRange float32
26337
26338                         // Set index in Palette with "palette_index" item meta field,
26339                         // this overrides Color.
26340                         Palette Texture
26341                         Color   color.NRGBA
26342
26343                         // Texture overlays.
26344                         InvOverlay, WieldOverlay Texture
26345
26346                         ShortDesc string
26347
26348                         PlaceParam2 uint8
26349                 }))(obj)).Groups) = make([]Group, local304)
26350                 for local305 := range (*(*(struct {
26351                         Type ItemType
26352
26353                         Name, Desc string
26354
26355                         InvImg, WieldImg Texture
26356                         WieldScale       [3]float32
26357
26358                         StackMax uint16
26359
26360                         Usable          bool
26361                         CanPointLiquids bool
26362
26363                         ToolCaps ToolCaps
26364
26365                         Groups []Group
26366
26367                         PlacePredict string
26368
26369                         PlaceSnd, PlaceFailSnd SoundDef
26370
26371                         PointRange float32
26372
26373                         // Set index in Palette with "palette_index" item meta field,
26374                         // this overrides Color.
26375                         Palette Texture
26376                         Color   color.NRGBA
26377
26378                         // Texture overlays.
26379                         InvOverlay, WieldOverlay Texture
26380
26381                         ShortDesc string
26382
26383                         PlaceParam2 uint8
26384                 }))(obj)).Groups {
26385                         if err := pcall(func() {
26386                                 (((*(*(struct {
26387                                         Type ItemType
26388
26389                                         Name, Desc string
26390
26391                                         InvImg, WieldImg Texture
26392                                         WieldScale       [3]float32
26393
26394                                         StackMax uint16
26395
26396                                         Usable          bool
26397                                         CanPointLiquids bool
26398
26399                                         ToolCaps ToolCaps
26400
26401                                         Groups []Group
26402
26403                                         PlacePredict string
26404
26405                                         PlaceSnd, PlaceFailSnd SoundDef
26406
26407                                         PointRange float32
26408
26409                                         // Set index in Palette with "palette_index" item meta field,
26410                                         // this overrides Color.
26411                                         Palette Texture
26412                                         Color   color.NRGBA
26413
26414                                         // Texture overlays.
26415                                         InvOverlay, WieldOverlay Texture
26416
26417                                         ShortDesc string
26418
26419                                         PlaceParam2 uint8
26420                                 }))(obj)).Groups)[local305]).Deserialize(r)
26421                         }); err != nil {
26422                                 if err == io.EOF {
26423                                         chk(io.EOF)
26424                                 }
26425                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
26426                         }
26427                 }
26428                 var local306 []uint8
26429                 var local307 uint16
26430                 {
26431                         p := &local307
26432                         *p = read16(r)
26433                 }
26434                 (local306) = make([]uint8, local307)
26435                 {
26436                         _, err := io.ReadFull(r, (local306)[:])
26437                         chk(err)
26438                 }
26439                 ((*(*(struct {
26440                         Type ItemType
26441
26442                         Name, Desc string
26443
26444                         InvImg, WieldImg Texture
26445                         WieldScale       [3]float32
26446
26447                         StackMax uint16
26448
26449                         Usable          bool
26450                         CanPointLiquids bool
26451
26452                         ToolCaps ToolCaps
26453
26454                         Groups []Group
26455
26456                         PlacePredict string
26457
26458                         PlaceSnd, PlaceFailSnd SoundDef
26459
26460                         PointRange float32
26461
26462                         // Set index in Palette with "palette_index" item meta field,
26463                         // this overrides Color.
26464                         Palette Texture
26465                         Color   color.NRGBA
26466
26467                         // Texture overlays.
26468                         InvOverlay, WieldOverlay Texture
26469
26470                         ShortDesc string
26471
26472                         PlaceParam2 uint8
26473                 }))(obj)).PlacePredict) = string(local306)
26474                 if err := pcall(func() {
26475                         ((*(*(struct {
26476                                 Type ItemType
26477
26478                                 Name, Desc string
26479
26480                                 InvImg, WieldImg Texture
26481                                 WieldScale       [3]float32
26482
26483                                 StackMax uint16
26484
26485                                 Usable          bool
26486                                 CanPointLiquids bool
26487
26488                                 ToolCaps ToolCaps
26489
26490                                 Groups []Group
26491
26492                                 PlacePredict string
26493
26494                                 PlaceSnd, PlaceFailSnd SoundDef
26495
26496                                 PointRange float32
26497
26498                                 // Set index in Palette with "palette_index" item meta field,
26499                                 // this overrides Color.
26500                                 Palette Texture
26501                                 Color   color.NRGBA
26502
26503                                 // Texture overlays.
26504                                 InvOverlay, WieldOverlay Texture
26505
26506                                 ShortDesc string
26507
26508                                 PlaceParam2 uint8
26509                         }))(obj)).PlaceSnd).Deserialize(r)
26510                 }); err != nil {
26511                         if err == io.EOF {
26512                                 chk(io.EOF)
26513                         }
26514                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
26515                 }
26516                 if err := pcall(func() {
26517                         ((*(*(struct {
26518                                 Type ItemType
26519
26520                                 Name, Desc string
26521
26522                                 InvImg, WieldImg Texture
26523                                 WieldScale       [3]float32
26524
26525                                 StackMax uint16
26526
26527                                 Usable          bool
26528                                 CanPointLiquids bool
26529
26530                                 ToolCaps ToolCaps
26531
26532                                 Groups []Group
26533
26534                                 PlacePredict string
26535
26536                                 PlaceSnd, PlaceFailSnd SoundDef
26537
26538                                 PointRange float32
26539
26540                                 // Set index in Palette with "palette_index" item meta field,
26541                                 // this overrides Color.
26542                                 Palette Texture
26543                                 Color   color.NRGBA
26544
26545                                 // Texture overlays.
26546                                 InvOverlay, WieldOverlay Texture
26547
26548                                 ShortDesc string
26549
26550                                 PlaceParam2 uint8
26551                         }))(obj)).PlaceFailSnd).Deserialize(r)
26552                 }); err != nil {
26553                         if err == io.EOF {
26554                                 chk(io.EOF)
26555                         }
26556                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
26557                 }
26558                 {
26559                         p := &(*(*(struct {
26560                                 Type ItemType
26561
26562                                 Name, Desc string
26563
26564                                 InvImg, WieldImg Texture
26565                                 WieldScale       [3]float32
26566
26567                                 StackMax uint16
26568
26569                                 Usable          bool
26570                                 CanPointLiquids bool
26571
26572                                 ToolCaps ToolCaps
26573
26574                                 Groups []Group
26575
26576                                 PlacePredict string
26577
26578                                 PlaceSnd, PlaceFailSnd SoundDef
26579
26580                                 PointRange float32
26581
26582                                 // Set index in Palette with "palette_index" item meta field,
26583                                 // this overrides Color.
26584                                 Palette Texture
26585                                 Color   color.NRGBA
26586
26587                                 // Texture overlays.
26588                                 InvOverlay, WieldOverlay Texture
26589
26590                                 ShortDesc string
26591
26592                                 PlaceParam2 uint8
26593                         }))(obj)).PointRange
26594                         *p = math.Float32frombits(read32(r))
26595                 }
26596                 if err := pcall(func() {
26597                         ((*(*(struct {
26598                                 Type ItemType
26599
26600                                 Name, Desc string
26601
26602                                 InvImg, WieldImg Texture
26603                                 WieldScale       [3]float32
26604
26605                                 StackMax uint16
26606
26607                                 Usable          bool
26608                                 CanPointLiquids bool
26609
26610                                 ToolCaps ToolCaps
26611
26612                                 Groups []Group
26613
26614                                 PlacePredict string
26615
26616                                 PlaceSnd, PlaceFailSnd SoundDef
26617
26618                                 PointRange float32
26619
26620                                 // Set index in Palette with "palette_index" item meta field,
26621                                 // this overrides Color.
26622                                 Palette Texture
26623                                 Color   color.NRGBA
26624
26625                                 // Texture overlays.
26626                                 InvOverlay, WieldOverlay Texture
26627
26628                                 ShortDesc string
26629
26630                                 PlaceParam2 uint8
26631                         }))(obj)).Palette).Deserialize(r)
26632                 }); err != nil {
26633                         if err == io.EOF {
26634                                 chk(io.EOF)
26635                         }
26636                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26637                 }
26638                 {
26639                         p := &(*(*(struct {
26640                                 Type ItemType
26641
26642                                 Name, Desc string
26643
26644                                 InvImg, WieldImg Texture
26645                                 WieldScale       [3]float32
26646
26647                                 StackMax uint16
26648
26649                                 Usable          bool
26650                                 CanPointLiquids bool
26651
26652                                 ToolCaps ToolCaps
26653
26654                                 Groups []Group
26655
26656                                 PlacePredict string
26657
26658                                 PlaceSnd, PlaceFailSnd SoundDef
26659
26660                                 PointRange float32
26661
26662                                 // Set index in Palette with "palette_index" item meta field,
26663                                 // this overrides Color.
26664                                 Palette Texture
26665                                 Color   color.NRGBA
26666
26667                                 // Texture overlays.
26668                                 InvOverlay, WieldOverlay Texture
26669
26670                                 ShortDesc string
26671
26672                                 PlaceParam2 uint8
26673                         }))(obj)).Color
26674                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
26675                 }
26676                 if err := pcall(func() {
26677                         ((*(*(struct {
26678                                 Type ItemType
26679
26680                                 Name, Desc string
26681
26682                                 InvImg, WieldImg Texture
26683                                 WieldScale       [3]float32
26684
26685                                 StackMax uint16
26686
26687                                 Usable          bool
26688                                 CanPointLiquids bool
26689
26690                                 ToolCaps ToolCaps
26691
26692                                 Groups []Group
26693
26694                                 PlacePredict string
26695
26696                                 PlaceSnd, PlaceFailSnd SoundDef
26697
26698                                 PointRange float32
26699
26700                                 // Set index in Palette with "palette_index" item meta field,
26701                                 // this overrides Color.
26702                                 Palette Texture
26703                                 Color   color.NRGBA
26704
26705                                 // Texture overlays.
26706                                 InvOverlay, WieldOverlay Texture
26707
26708                                 ShortDesc string
26709
26710                                 PlaceParam2 uint8
26711                         }))(obj)).InvOverlay).Deserialize(r)
26712                 }); err != nil {
26713                         if err == io.EOF {
26714                                 chk(io.EOF)
26715                         }
26716                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26717                 }
26718                 if err := pcall(func() {
26719                         ((*(*(struct {
26720                                 Type ItemType
26721
26722                                 Name, Desc string
26723
26724                                 InvImg, WieldImg Texture
26725                                 WieldScale       [3]float32
26726
26727                                 StackMax uint16
26728
26729                                 Usable          bool
26730                                 CanPointLiquids bool
26731
26732                                 ToolCaps ToolCaps
26733
26734                                 Groups []Group
26735
26736                                 PlacePredict string
26737
26738                                 PlaceSnd, PlaceFailSnd SoundDef
26739
26740                                 PointRange float32
26741
26742                                 // Set index in Palette with "palette_index" item meta field,
26743                                 // this overrides Color.
26744                                 Palette Texture
26745                                 Color   color.NRGBA
26746
26747                                 // Texture overlays.
26748                                 InvOverlay, WieldOverlay Texture
26749
26750                                 ShortDesc string
26751
26752                                 PlaceParam2 uint8
26753                         }))(obj)).WieldOverlay).Deserialize(r)
26754                 }); err != nil {
26755                         if err == io.EOF {
26756                                 chk(io.EOF)
26757                         }
26758                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26759                 }
26760                 var local308 []uint8
26761                 var local309 uint16
26762                 {
26763                         p := &local309
26764                         *p = read16(r)
26765                 }
26766                 (local308) = make([]uint8, local309)
26767                 {
26768                         _, err := io.ReadFull(r, (local308)[:])
26769                         chk(err)
26770                 }
26771                 ((*(*(struct {
26772                         Type ItemType
26773
26774                         Name, Desc string
26775
26776                         InvImg, WieldImg Texture
26777                         WieldScale       [3]float32
26778
26779                         StackMax uint16
26780
26781                         Usable          bool
26782                         CanPointLiquids bool
26783
26784                         ToolCaps ToolCaps
26785
26786                         Groups []Group
26787
26788                         PlacePredict string
26789
26790                         PlaceSnd, PlaceFailSnd SoundDef
26791
26792                         PointRange float32
26793
26794                         // Set index in Palette with "palette_index" item meta field,
26795                         // this overrides Color.
26796                         Palette Texture
26797                         Color   color.NRGBA
26798
26799                         // Texture overlays.
26800                         InvOverlay, WieldOverlay Texture
26801
26802                         ShortDesc string
26803
26804                         PlaceParam2 uint8
26805                 }))(obj)).ShortDesc) = string(local308)
26806                 {
26807                         p := &(*(*(struct {
26808                                 Type ItemType
26809
26810                                 Name, Desc string
26811
26812                                 InvImg, WieldImg Texture
26813                                 WieldScale       [3]float32
26814
26815                                 StackMax uint16
26816
26817                                 Usable          bool
26818                                 CanPointLiquids bool
26819
26820                                 ToolCaps ToolCaps
26821
26822                                 Groups []Group
26823
26824                                 PlacePredict string
26825
26826                                 PlaceSnd, PlaceFailSnd SoundDef
26827
26828                                 PointRange float32
26829
26830                                 // Set index in Palette with "palette_index" item meta field,
26831                                 // this overrides Color.
26832                                 Palette Texture
26833                                 Color   color.NRGBA
26834
26835                                 // Texture overlays.
26836                                 InvOverlay, WieldOverlay Texture
26837
26838                                 ShortDesc string
26839
26840                                 PlaceParam2 uint8
26841                         }))(obj)).PlaceParam2
26842                         *p = read8(r)
26843                 }
26844                 if r.N > 0 {
26845                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
26846                 }
26847         }
26848 }
26849
26850 func (obj *SoundSrcType) Serialize(w io.Writer) {
26851         {
26852                 x := *(*(uint8))(obj)
26853                 write8(w, uint8(x))
26854         }
26855 }
26856
26857 func (obj *SoundSrcType) Deserialize(r io.Reader) {
26858         {
26859                 p := &*(*(uint8))(obj)
26860                 *p = read8(r)
26861         }
26862 }
26863
26864 func (obj *TileAnim) Serialize(w io.Writer) {
26865         if err := pcall(func() {
26866                 ((*(*(struct {
26867                         Type AnimType
26868
26869                         //mt:if %s.Type == SpriteSheetAnim
26870                         AspectRatio [2]uint8
26871
26872                         //mt:if %s.Type == VerticalFrameAnim
26873                         NFrames [2]uint16
26874
26875                         //mt:if %s.Type != NoAnim
26876                         Duration float32 // in seconds
26877
26878                 }))(obj)).Type).Serialize(w)
26879         }); err != nil {
26880                 if err == io.EOF {
26881                         chk(io.EOF)
26882                 }
26883                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AnimType", err))
26884         }
26885         if !((*(*(struct {
26886                 Type AnimType
26887
26888                 //mt:if %s.Type == SpriteSheetAnim
26889                 AspectRatio [2]uint8
26890
26891                 //mt:if %s.Type == VerticalFrameAnim
26892                 NFrames [2]uint16
26893
26894                 //mt:if %s.Type != NoAnim
26895                 Duration float32 // in seconds
26896
26897         }))(obj)).Type < maxAnim) {
26898                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
26899         }
26900         if (*(*(struct {
26901                 Type AnimType
26902
26903                 //mt:if %s.Type == SpriteSheetAnim
26904                 AspectRatio [2]uint8
26905
26906                 //mt:if %s.Type == VerticalFrameAnim
26907                 NFrames [2]uint16
26908
26909                 //mt:if %s.Type != NoAnim
26910                 Duration float32 // in seconds
26911
26912         }))(obj)).Type == SpriteSheetAnim {
26913                 {
26914                         _, err := w.Write(((*(*(struct {
26915                                 Type AnimType
26916
26917                                 //mt:if %s.Type == SpriteSheetAnim
26918                                 AspectRatio [2]uint8
26919
26920                                 //mt:if %s.Type == VerticalFrameAnim
26921                                 NFrames [2]uint16
26922
26923                                 //mt:if %s.Type != NoAnim
26924                                 Duration float32 // in seconds
26925
26926                         }))(obj)).AspectRatio)[:])
26927                         chk(err)
26928                 }
26929         }
26930         if (*(*(struct {
26931                 Type AnimType
26932
26933                 //mt:if %s.Type == SpriteSheetAnim
26934                 AspectRatio [2]uint8
26935
26936                 //mt:if %s.Type == VerticalFrameAnim
26937                 NFrames [2]uint16
26938
26939                 //mt:if %s.Type != NoAnim
26940                 Duration float32 // in seconds
26941
26942         }))(obj)).Type == VerticalFrameAnim {
26943                 for local310 := range (*(*(struct {
26944                         Type AnimType
26945
26946                         //mt:if %s.Type == SpriteSheetAnim
26947                         AspectRatio [2]uint8
26948
26949                         //mt:if %s.Type == VerticalFrameAnim
26950                         NFrames [2]uint16
26951
26952                         //mt:if %s.Type != NoAnim
26953                         Duration float32 // in seconds
26954
26955                 }))(obj)).NFrames {
26956                         {
26957                                 x := ((*(*(struct {
26958                                         Type AnimType
26959
26960                                         //mt:if %s.Type == SpriteSheetAnim
26961                                         AspectRatio [2]uint8
26962
26963                                         //mt:if %s.Type == VerticalFrameAnim
26964                                         NFrames [2]uint16
26965
26966                                         //mt:if %s.Type != NoAnim
26967                                         Duration float32 // in seconds
26968
26969                                 }))(obj)).NFrames)[local310]
26970                                 write16(w, uint16(x))
26971                         }
26972                 }
26973         }
26974         if (*(*(struct {
26975                 Type AnimType
26976
26977                 //mt:if %s.Type == SpriteSheetAnim
26978                 AspectRatio [2]uint8
26979
26980                 //mt:if %s.Type == VerticalFrameAnim
26981                 NFrames [2]uint16
26982
26983                 //mt:if %s.Type != NoAnim
26984                 Duration float32 // in seconds
26985
26986         }))(obj)).Type != NoAnim {
26987                 {
26988                         x := (*(*(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)).Duration
27001                         write32(w, math.Float32bits(x))
27002                 }
27003         }
27004 }
27005
27006 func (obj *TileAnim) Deserialize(r io.Reader) {
27007         if err := pcall(func() {
27008                 ((*(*(struct {
27009                         Type AnimType
27010
27011                         //mt:if %s.Type == SpriteSheetAnim
27012                         AspectRatio [2]uint8
27013
27014                         //mt:if %s.Type == VerticalFrameAnim
27015                         NFrames [2]uint16
27016
27017                         //mt:if %s.Type != NoAnim
27018                         Duration float32 // in seconds
27019
27020                 }))(obj)).Type).Deserialize(r)
27021         }); err != nil {
27022                 if err == io.EOF {
27023                         chk(io.EOF)
27024                 }
27025                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AnimType", err))
27026         }
27027         if !((*(*(struct {
27028                 Type AnimType
27029
27030                 //mt:if %s.Type == SpriteSheetAnim
27031                 AspectRatio [2]uint8
27032
27033                 //mt:if %s.Type == VerticalFrameAnim
27034                 NFrames [2]uint16
27035
27036                 //mt:if %s.Type != NoAnim
27037                 Duration float32 // in seconds
27038
27039         }))(obj)).Type < maxAnim) {
27040                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
27041         }
27042         if (*(*(struct {
27043                 Type AnimType
27044
27045                 //mt:if %s.Type == SpriteSheetAnim
27046                 AspectRatio [2]uint8
27047
27048                 //mt:if %s.Type == VerticalFrameAnim
27049                 NFrames [2]uint16
27050
27051                 //mt:if %s.Type != NoAnim
27052                 Duration float32 // in seconds
27053
27054         }))(obj)).Type == SpriteSheetAnim {
27055                 {
27056                         _, err := io.ReadFull(r, ((*(*(struct {
27057                                 Type AnimType
27058
27059                                 //mt:if %s.Type == SpriteSheetAnim
27060                                 AspectRatio [2]uint8
27061
27062                                 //mt:if %s.Type == VerticalFrameAnim
27063                                 NFrames [2]uint16
27064
27065                                 //mt:if %s.Type != NoAnim
27066                                 Duration float32 // in seconds
27067
27068                         }))(obj)).AspectRatio)[:])
27069                         chk(err)
27070                 }
27071         }
27072         if (*(*(struct {
27073                 Type AnimType
27074
27075                 //mt:if %s.Type == SpriteSheetAnim
27076                 AspectRatio [2]uint8
27077
27078                 //mt:if %s.Type == VerticalFrameAnim
27079                 NFrames [2]uint16
27080
27081                 //mt:if %s.Type != NoAnim
27082                 Duration float32 // in seconds
27083
27084         }))(obj)).Type == VerticalFrameAnim {
27085                 for local311 := range (*(*(struct {
27086                         Type AnimType
27087
27088                         //mt:if %s.Type == SpriteSheetAnim
27089                         AspectRatio [2]uint8
27090
27091                         //mt:if %s.Type == VerticalFrameAnim
27092                         NFrames [2]uint16
27093
27094                         //mt:if %s.Type != NoAnim
27095                         Duration float32 // in seconds
27096
27097                 }))(obj)).NFrames {
27098                         {
27099                                 p := &((*(*(struct {
27100                                         Type AnimType
27101
27102                                         //mt:if %s.Type == SpriteSheetAnim
27103                                         AspectRatio [2]uint8
27104
27105                                         //mt:if %s.Type == VerticalFrameAnim
27106                                         NFrames [2]uint16
27107
27108                                         //mt:if %s.Type != NoAnim
27109                                         Duration float32 // in seconds
27110
27111                                 }))(obj)).NFrames)[local311]
27112                                 *p = read16(r)
27113                         }
27114                 }
27115         }
27116         if (*(*(struct {
27117                 Type AnimType
27118
27119                 //mt:if %s.Type == SpriteSheetAnim
27120                 AspectRatio [2]uint8
27121
27122                 //mt:if %s.Type == VerticalFrameAnim
27123                 NFrames [2]uint16
27124
27125                 //mt:if %s.Type != NoAnim
27126                 Duration float32 // in seconds
27127
27128         }))(obj)).Type != NoAnim {
27129                 {
27130                         p := &(*(*(struct {
27131                                 Type AnimType
27132
27133                                 //mt:if %s.Type == SpriteSheetAnim
27134                                 AspectRatio [2]uint8
27135
27136                                 //mt:if %s.Type == VerticalFrameAnim
27137                                 NFrames [2]uint16
27138
27139                                 //mt:if %s.Type != NoAnim
27140                                 Duration float32 // in seconds
27141
27142                         }))(obj)).Duration
27143                         *p = math.Float32frombits(read32(r))
27144                 }
27145         }
27146 }
27147
27148 func (obj *Content) Serialize(w io.Writer) {
27149         {
27150                 x := *(*(uint16))(obj)
27151                 write16(w, uint16(x))
27152         }
27153 }
27154
27155 func (obj *Content) Deserialize(r io.Reader) {
27156         {
27157                 p := &*(*(uint16))(obj)
27158                 *p = read16(r)
27159         }
27160 }
27161
27162 func (obj *ParticleSpawnerID) Serialize(w io.Writer) {
27163         {
27164                 x := *(*(uint32))(obj)
27165                 write32(w, uint32(x))
27166         }
27167 }
27168
27169 func (obj *ParticleSpawnerID) Deserialize(r io.Reader) {
27170         {
27171                 p := &*(*(uint32))(obj)
27172                 *p = read32(r)
27173         }
27174 }
27175
27176 func (obj *HUDID) Serialize(w io.Writer) {
27177         {
27178                 x := *(*(uint32))(obj)
27179                 write32(w, uint32(x))
27180         }
27181 }
27182
27183 func (obj *HUDID) Deserialize(r io.Reader) {
27184         {
27185                 p := &*(*(uint32))(obj)
27186                 *p = read32(r)
27187         }
27188 }
27189
27190 func (obj *HUD) Serialize(w io.Writer) {
27191         if err := pcall(func() {
27192                 ((*(*(struct {
27193                         Type HUDType
27194
27195                         Pos      [2]float32
27196                         Name     string
27197                         Scale    [2]float32
27198                         Text     string
27199                         Number   uint32
27200                         Item     uint32
27201                         Dir      uint32
27202                         Align    [2]float32
27203                         Offset   [2]float32
27204                         WorldPos Pos
27205                         Size     [2]int32
27206                         ZIndex   int16
27207                         Text2    string
27208                         Style    HUDStyleFlags
27209                 }))(obj)).Type).Serialize(w)
27210         }); err != nil {
27211                 if err == io.EOF {
27212                         chk(io.EOF)
27213                 }
27214                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
27215         }
27216         for local312 := range (*(*(struct {
27217                 Type HUDType
27218
27219                 Pos      [2]float32
27220                 Name     string
27221                 Scale    [2]float32
27222                 Text     string
27223                 Number   uint32
27224                 Item     uint32
27225                 Dir      uint32
27226                 Align    [2]float32
27227                 Offset   [2]float32
27228                 WorldPos Pos
27229                 Size     [2]int32
27230                 ZIndex   int16
27231                 Text2    string
27232                 Style    HUDStyleFlags
27233         }))(obj)).Pos {
27234                 {
27235                         x := ((*(*(struct {
27236                                 Type HUDType
27237
27238                                 Pos      [2]float32
27239                                 Name     string
27240                                 Scale    [2]float32
27241                                 Text     string
27242                                 Number   uint32
27243                                 Item     uint32
27244                                 Dir      uint32
27245                                 Align    [2]float32
27246                                 Offset   [2]float32
27247                                 WorldPos Pos
27248                                 Size     [2]int32
27249                                 ZIndex   int16
27250                                 Text2    string
27251                                 Style    HUDStyleFlags
27252                         }))(obj)).Pos)[local312]
27253                         write32(w, math.Float32bits(x))
27254                 }
27255         }
27256         if len(([]byte((*(*(struct {
27257                 Type HUDType
27258
27259                 Pos      [2]float32
27260                 Name     string
27261                 Scale    [2]float32
27262                 Text     string
27263                 Number   uint32
27264                 Item     uint32
27265                 Dir      uint32
27266                 Align    [2]float32
27267                 Offset   [2]float32
27268                 WorldPos Pos
27269                 Size     [2]int32
27270                 ZIndex   int16
27271                 Text2    string
27272                 Style    HUDStyleFlags
27273         }))(obj)).Name))) > math.MaxUint16 {
27274                 chk(ErrTooLong)
27275         }
27276         {
27277                 x := uint16(len(([]byte((*(*(struct {
27278                         Type HUDType
27279
27280                         Pos      [2]float32
27281                         Name     string
27282                         Scale    [2]float32
27283                         Text     string
27284                         Number   uint32
27285                         Item     uint32
27286                         Dir      uint32
27287                         Align    [2]float32
27288                         Offset   [2]float32
27289                         WorldPos Pos
27290                         Size     [2]int32
27291                         ZIndex   int16
27292                         Text2    string
27293                         Style    HUDStyleFlags
27294                 }))(obj)).Name))))
27295                 write16(w, uint16(x))
27296         }
27297         {
27298                 _, err := w.Write(([]byte((*(*(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)).Name))[:])
27316                 chk(err)
27317         }
27318         for local313 := range (*(*(struct {
27319                 Type HUDType
27320
27321                 Pos      [2]float32
27322                 Name     string
27323                 Scale    [2]float32
27324                 Text     string
27325                 Number   uint32
27326                 Item     uint32
27327                 Dir      uint32
27328                 Align    [2]float32
27329                 Offset   [2]float32
27330                 WorldPos Pos
27331                 Size     [2]int32
27332                 ZIndex   int16
27333                 Text2    string
27334                 Style    HUDStyleFlags
27335         }))(obj)).Scale {
27336                 {
27337                         x := ((*(*(struct {
27338                                 Type HUDType
27339
27340                                 Pos      [2]float32
27341                                 Name     string
27342                                 Scale    [2]float32
27343                                 Text     string
27344                                 Number   uint32
27345                                 Item     uint32
27346                                 Dir      uint32
27347                                 Align    [2]float32
27348                                 Offset   [2]float32
27349                                 WorldPos Pos
27350                                 Size     [2]int32
27351                                 ZIndex   int16
27352                                 Text2    string
27353                                 Style    HUDStyleFlags
27354                         }))(obj)).Scale)[local313]
27355                         write32(w, math.Float32bits(x))
27356                 }
27357         }
27358         if len(([]byte((*(*(struct {
27359                 Type HUDType
27360
27361                 Pos      [2]float32
27362                 Name     string
27363                 Scale    [2]float32
27364                 Text     string
27365                 Number   uint32
27366                 Item     uint32
27367                 Dir      uint32
27368                 Align    [2]float32
27369                 Offset   [2]float32
27370                 WorldPos Pos
27371                 Size     [2]int32
27372                 ZIndex   int16
27373                 Text2    string
27374                 Style    HUDStyleFlags
27375         }))(obj)).Text))) > math.MaxUint16 {
27376                 chk(ErrTooLong)
27377         }
27378         {
27379                 x := uint16(len(([]byte((*(*(struct {
27380                         Type HUDType
27381
27382                         Pos      [2]float32
27383                         Name     string
27384                         Scale    [2]float32
27385                         Text     string
27386                         Number   uint32
27387                         Item     uint32
27388                         Dir      uint32
27389                         Align    [2]float32
27390                         Offset   [2]float32
27391                         WorldPos Pos
27392                         Size     [2]int32
27393                         ZIndex   int16
27394                         Text2    string
27395                         Style    HUDStyleFlags
27396                 }))(obj)).Text))))
27397                 write16(w, uint16(x))
27398         }
27399         {
27400                 _, err := w.Write(([]byte((*(*(struct {
27401                         Type HUDType
27402
27403                         Pos      [2]float32
27404                         Name     string
27405                         Scale    [2]float32
27406                         Text     string
27407                         Number   uint32
27408                         Item     uint32
27409                         Dir      uint32
27410                         Align    [2]float32
27411                         Offset   [2]float32
27412                         WorldPos Pos
27413                         Size     [2]int32
27414                         ZIndex   int16
27415                         Text2    string
27416                         Style    HUDStyleFlags
27417                 }))(obj)).Text))[:])
27418                 chk(err)
27419         }
27420         {
27421                 x := (*(*(struct {
27422                         Type HUDType
27423
27424                         Pos      [2]float32
27425                         Name     string
27426                         Scale    [2]float32
27427                         Text     string
27428                         Number   uint32
27429                         Item     uint32
27430                         Dir      uint32
27431                         Align    [2]float32
27432                         Offset   [2]float32
27433                         WorldPos Pos
27434                         Size     [2]int32
27435                         ZIndex   int16
27436                         Text2    string
27437                         Style    HUDStyleFlags
27438                 }))(obj)).Number
27439                 write32(w, uint32(x))
27440         }
27441         {
27442                 x := (*(*(struct {
27443                         Type HUDType
27444
27445                         Pos      [2]float32
27446                         Name     string
27447                         Scale    [2]float32
27448                         Text     string
27449                         Number   uint32
27450                         Item     uint32
27451                         Dir      uint32
27452                         Align    [2]float32
27453                         Offset   [2]float32
27454                         WorldPos Pos
27455                         Size     [2]int32
27456                         ZIndex   int16
27457                         Text2    string
27458                         Style    HUDStyleFlags
27459                 }))(obj)).Item
27460                 write32(w, uint32(x))
27461         }
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)).Dir
27481                 write32(w, uint32(x))
27482         }
27483         for local314 := range (*(*(struct {
27484                 Type HUDType
27485
27486                 Pos      [2]float32
27487                 Name     string
27488                 Scale    [2]float32
27489                 Text     string
27490                 Number   uint32
27491                 Item     uint32
27492                 Dir      uint32
27493                 Align    [2]float32
27494                 Offset   [2]float32
27495                 WorldPos Pos
27496                 Size     [2]int32
27497                 ZIndex   int16
27498                 Text2    string
27499                 Style    HUDStyleFlags
27500         }))(obj)).Align {
27501                 {
27502                         x := ((*(*(struct {
27503                                 Type HUDType
27504
27505                                 Pos      [2]float32
27506                                 Name     string
27507                                 Scale    [2]float32
27508                                 Text     string
27509                                 Number   uint32
27510                                 Item     uint32
27511                                 Dir      uint32
27512                                 Align    [2]float32
27513                                 Offset   [2]float32
27514                                 WorldPos Pos
27515                                 Size     [2]int32
27516                                 ZIndex   int16
27517                                 Text2    string
27518                                 Style    HUDStyleFlags
27519                         }))(obj)).Align)[local314]
27520                         write32(w, math.Float32bits(x))
27521                 }
27522         }
27523         for local315 := range (*(*(struct {
27524                 Type HUDType
27525
27526                 Pos      [2]float32
27527                 Name     string
27528                 Scale    [2]float32
27529                 Text     string
27530                 Number   uint32
27531                 Item     uint32
27532                 Dir      uint32
27533                 Align    [2]float32
27534                 Offset   [2]float32
27535                 WorldPos Pos
27536                 Size     [2]int32
27537                 ZIndex   int16
27538                 Text2    string
27539                 Style    HUDStyleFlags
27540         }))(obj)).Offset {
27541                 {
27542                         x := ((*(*(struct {
27543                                 Type HUDType
27544
27545                                 Pos      [2]float32
27546                                 Name     string
27547                                 Scale    [2]float32
27548                                 Text     string
27549                                 Number   uint32
27550                                 Item     uint32
27551                                 Dir      uint32
27552                                 Align    [2]float32
27553                                 Offset   [2]float32
27554                                 WorldPos Pos
27555                                 Size     [2]int32
27556                                 ZIndex   int16
27557                                 Text2    string
27558                                 Style    HUDStyleFlags
27559                         }))(obj)).Offset)[local315]
27560                         write32(w, math.Float32bits(x))
27561                 }
27562         }
27563         if err := pcall(func() {
27564                 ((*(*(struct {
27565                         Type HUDType
27566
27567                         Pos      [2]float32
27568                         Name     string
27569                         Scale    [2]float32
27570                         Text     string
27571                         Number   uint32
27572                         Item     uint32
27573                         Dir      uint32
27574                         Align    [2]float32
27575                         Offset   [2]float32
27576                         WorldPos Pos
27577                         Size     [2]int32
27578                         ZIndex   int16
27579                         Text2    string
27580                         Style    HUDStyleFlags
27581                 }))(obj)).WorldPos).Serialize(w)
27582         }); err != nil {
27583                 if err == io.EOF {
27584                         chk(io.EOF)
27585                 }
27586                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
27587         }
27588         for local316 := range (*(*(struct {
27589                 Type HUDType
27590
27591                 Pos      [2]float32
27592                 Name     string
27593                 Scale    [2]float32
27594                 Text     string
27595                 Number   uint32
27596                 Item     uint32
27597                 Dir      uint32
27598                 Align    [2]float32
27599                 Offset   [2]float32
27600                 WorldPos Pos
27601                 Size     [2]int32
27602                 ZIndex   int16
27603                 Text2    string
27604                 Style    HUDStyleFlags
27605         }))(obj)).Size {
27606                 {
27607                         x := ((*(*(struct {
27608                                 Type HUDType
27609
27610                                 Pos      [2]float32
27611                                 Name     string
27612                                 Scale    [2]float32
27613                                 Text     string
27614                                 Number   uint32
27615                                 Item     uint32
27616                                 Dir      uint32
27617                                 Align    [2]float32
27618                                 Offset   [2]float32
27619                                 WorldPos Pos
27620                                 Size     [2]int32
27621                                 ZIndex   int16
27622                                 Text2    string
27623                                 Style    HUDStyleFlags
27624                         }))(obj)).Size)[local316]
27625                         write32(w, uint32(x))
27626                 }
27627         }
27628         {
27629                 x := (*(*(struct {
27630                         Type HUDType
27631
27632                         Pos      [2]float32
27633                         Name     string
27634                         Scale    [2]float32
27635                         Text     string
27636                         Number   uint32
27637                         Item     uint32
27638                         Dir      uint32
27639                         Align    [2]float32
27640                         Offset   [2]float32
27641                         WorldPos Pos
27642                         Size     [2]int32
27643                         ZIndex   int16
27644                         Text2    string
27645                         Style    HUDStyleFlags
27646                 }))(obj)).ZIndex
27647                 write16(w, uint16(x))
27648         }
27649         if len(([]byte((*(*(struct {
27650                 Type HUDType
27651
27652                 Pos      [2]float32
27653                 Name     string
27654                 Scale    [2]float32
27655                 Text     string
27656                 Number   uint32
27657                 Item     uint32
27658                 Dir      uint32
27659                 Align    [2]float32
27660                 Offset   [2]float32
27661                 WorldPos Pos
27662                 Size     [2]int32
27663                 ZIndex   int16
27664                 Text2    string
27665                 Style    HUDStyleFlags
27666         }))(obj)).Text2))) > math.MaxUint16 {
27667                 chk(ErrTooLong)
27668         }
27669         {
27670                 x := uint16(len(([]byte((*(*(struct {
27671                         Type HUDType
27672
27673                         Pos      [2]float32
27674                         Name     string
27675                         Scale    [2]float32
27676                         Text     string
27677                         Number   uint32
27678                         Item     uint32
27679                         Dir      uint32
27680                         Align    [2]float32
27681                         Offset   [2]float32
27682                         WorldPos Pos
27683                         Size     [2]int32
27684                         ZIndex   int16
27685                         Text2    string
27686                         Style    HUDStyleFlags
27687                 }))(obj)).Text2))))
27688                 write16(w, uint16(x))
27689         }
27690         {
27691                 _, err := w.Write(([]byte((*(*(struct {
27692                         Type HUDType
27693
27694                         Pos      [2]float32
27695                         Name     string
27696                         Scale    [2]float32
27697                         Text     string
27698                         Number   uint32
27699                         Item     uint32
27700                         Dir      uint32
27701                         Align    [2]float32
27702                         Offset   [2]float32
27703                         WorldPos Pos
27704                         Size     [2]int32
27705                         ZIndex   int16
27706                         Text2    string
27707                         Style    HUDStyleFlags
27708                 }))(obj)).Text2))[:])
27709                 chk(err)
27710         }
27711         if err := pcall(func() {
27712                 ((*(*(struct {
27713                         Type HUDType
27714
27715                         Pos      [2]float32
27716                         Name     string
27717                         Scale    [2]float32
27718                         Text     string
27719                         Number   uint32
27720                         Item     uint32
27721                         Dir      uint32
27722                         Align    [2]float32
27723                         Offset   [2]float32
27724                         WorldPos Pos
27725                         Size     [2]int32
27726                         ZIndex   int16
27727                         Text2    string
27728                         Style    HUDStyleFlags
27729                 }))(obj)).Style).Serialize(w)
27730         }); err != nil {
27731                 if err == io.EOF {
27732                         chk(io.EOF)
27733                 }
27734                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
27735         }
27736 }
27737
27738 func (obj *HUD) Deserialize(r io.Reader) {
27739         if err := pcall(func() {
27740                 ((*(*(struct {
27741                         Type HUDType
27742
27743                         Pos      [2]float32
27744                         Name     string
27745                         Scale    [2]float32
27746                         Text     string
27747                         Number   uint32
27748                         Item     uint32
27749                         Dir      uint32
27750                         Align    [2]float32
27751                         Offset   [2]float32
27752                         WorldPos Pos
27753                         Size     [2]int32
27754                         ZIndex   int16
27755                         Text2    string
27756                         Style    HUDStyleFlags
27757                 }))(obj)).Type).Deserialize(r)
27758         }); err != nil {
27759                 if err == io.EOF {
27760                         chk(io.EOF)
27761                 }
27762                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
27763         }
27764         for local317 := range (*(*(struct {
27765                 Type HUDType
27766
27767                 Pos      [2]float32
27768                 Name     string
27769                 Scale    [2]float32
27770                 Text     string
27771                 Number   uint32
27772                 Item     uint32
27773                 Dir      uint32
27774                 Align    [2]float32
27775                 Offset   [2]float32
27776                 WorldPos Pos
27777                 Size     [2]int32
27778                 ZIndex   int16
27779                 Text2    string
27780                 Style    HUDStyleFlags
27781         }))(obj)).Pos {
27782                 {
27783                         p := &((*(*(struct {
27784                                 Type HUDType
27785
27786                                 Pos      [2]float32
27787                                 Name     string
27788                                 Scale    [2]float32
27789                                 Text     string
27790                                 Number   uint32
27791                                 Item     uint32
27792                                 Dir      uint32
27793                                 Align    [2]float32
27794                                 Offset   [2]float32
27795                                 WorldPos Pos
27796                                 Size     [2]int32
27797                                 ZIndex   int16
27798                                 Text2    string
27799                                 Style    HUDStyleFlags
27800                         }))(obj)).Pos)[local317]
27801                         *p = math.Float32frombits(read32(r))
27802                 }
27803         }
27804         var local318 []uint8
27805         var local319 uint16
27806         {
27807                 p := &local319
27808                 *p = read16(r)
27809         }
27810         (local318) = make([]uint8, local319)
27811         {
27812                 _, err := io.ReadFull(r, (local318)[:])
27813                 chk(err)
27814         }
27815         ((*(*(struct {
27816                 Type HUDType
27817
27818                 Pos      [2]float32
27819                 Name     string
27820                 Scale    [2]float32
27821                 Text     string
27822                 Number   uint32
27823                 Item     uint32
27824                 Dir      uint32
27825                 Align    [2]float32
27826                 Offset   [2]float32
27827                 WorldPos Pos
27828                 Size     [2]int32
27829                 ZIndex   int16
27830                 Text2    string
27831                 Style    HUDStyleFlags
27832         }))(obj)).Name) = string(local318)
27833         for local320 := range (*(*(struct {
27834                 Type HUDType
27835
27836                 Pos      [2]float32
27837                 Name     string
27838                 Scale    [2]float32
27839                 Text     string
27840                 Number   uint32
27841                 Item     uint32
27842                 Dir      uint32
27843                 Align    [2]float32
27844                 Offset   [2]float32
27845                 WorldPos Pos
27846                 Size     [2]int32
27847                 ZIndex   int16
27848                 Text2    string
27849                 Style    HUDStyleFlags
27850         }))(obj)).Scale {
27851                 {
27852                         p := &((*(*(struct {
27853                                 Type HUDType
27854
27855                                 Pos      [2]float32
27856                                 Name     string
27857                                 Scale    [2]float32
27858                                 Text     string
27859                                 Number   uint32
27860                                 Item     uint32
27861                                 Dir      uint32
27862                                 Align    [2]float32
27863                                 Offset   [2]float32
27864                                 WorldPos Pos
27865                                 Size     [2]int32
27866                                 ZIndex   int16
27867                                 Text2    string
27868                                 Style    HUDStyleFlags
27869                         }))(obj)).Scale)[local320]
27870                         *p = math.Float32frombits(read32(r))
27871                 }
27872         }
27873         var local321 []uint8
27874         var local322 uint16
27875         {
27876                 p := &local322
27877                 *p = read16(r)
27878         }
27879         (local321) = make([]uint8, local322)
27880         {
27881                 _, err := io.ReadFull(r, (local321)[:])
27882                 chk(err)
27883         }
27884         ((*(*(struct {
27885                 Type HUDType
27886
27887                 Pos      [2]float32
27888                 Name     string
27889                 Scale    [2]float32
27890                 Text     string
27891                 Number   uint32
27892                 Item     uint32
27893                 Dir      uint32
27894                 Align    [2]float32
27895                 Offset   [2]float32
27896                 WorldPos Pos
27897                 Size     [2]int32
27898                 ZIndex   int16
27899                 Text2    string
27900                 Style    HUDStyleFlags
27901         }))(obj)).Text) = string(local321)
27902         {
27903                 p := &(*(*(struct {
27904                         Type HUDType
27905
27906                         Pos      [2]float32
27907                         Name     string
27908                         Scale    [2]float32
27909                         Text     string
27910                         Number   uint32
27911                         Item     uint32
27912                         Dir      uint32
27913                         Align    [2]float32
27914                         Offset   [2]float32
27915                         WorldPos Pos
27916                         Size     [2]int32
27917                         ZIndex   int16
27918                         Text2    string
27919                         Style    HUDStyleFlags
27920                 }))(obj)).Number
27921                 *p = read32(r)
27922         }
27923         {
27924                 p := &(*(*(struct {
27925                         Type HUDType
27926
27927                         Pos      [2]float32
27928                         Name     string
27929                         Scale    [2]float32
27930                         Text     string
27931                         Number   uint32
27932                         Item     uint32
27933                         Dir      uint32
27934                         Align    [2]float32
27935                         Offset   [2]float32
27936                         WorldPos Pos
27937                         Size     [2]int32
27938                         ZIndex   int16
27939                         Text2    string
27940                         Style    HUDStyleFlags
27941                 }))(obj)).Item
27942                 *p = read32(r)
27943         }
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)).Dir
27963                 *p = read32(r)
27964         }
27965         for local323 := range (*(*(struct {
27966                 Type HUDType
27967
27968                 Pos      [2]float32
27969                 Name     string
27970                 Scale    [2]float32
27971                 Text     string
27972                 Number   uint32
27973                 Item     uint32
27974                 Dir      uint32
27975                 Align    [2]float32
27976                 Offset   [2]float32
27977                 WorldPos Pos
27978                 Size     [2]int32
27979                 ZIndex   int16
27980                 Text2    string
27981                 Style    HUDStyleFlags
27982         }))(obj)).Align {
27983                 {
27984                         p := &((*(*(struct {
27985                                 Type HUDType
27986
27987                                 Pos      [2]float32
27988                                 Name     string
27989                                 Scale    [2]float32
27990                                 Text     string
27991                                 Number   uint32
27992                                 Item     uint32
27993                                 Dir      uint32
27994                                 Align    [2]float32
27995                                 Offset   [2]float32
27996                                 WorldPos Pos
27997                                 Size     [2]int32
27998                                 ZIndex   int16
27999                                 Text2    string
28000                                 Style    HUDStyleFlags
28001                         }))(obj)).Align)[local323]
28002                         *p = math.Float32frombits(read32(r))
28003                 }
28004         }
28005         for local324 := range (*(*(struct {
28006                 Type HUDType
28007
28008                 Pos      [2]float32
28009                 Name     string
28010                 Scale    [2]float32
28011                 Text     string
28012                 Number   uint32
28013                 Item     uint32
28014                 Dir      uint32
28015                 Align    [2]float32
28016                 Offset   [2]float32
28017                 WorldPos Pos
28018                 Size     [2]int32
28019                 ZIndex   int16
28020                 Text2    string
28021                 Style    HUDStyleFlags
28022         }))(obj)).Offset {
28023                 {
28024                         p := &((*(*(struct {
28025                                 Type HUDType
28026
28027                                 Pos      [2]float32
28028                                 Name     string
28029                                 Scale    [2]float32
28030                                 Text     string
28031                                 Number   uint32
28032                                 Item     uint32
28033                                 Dir      uint32
28034                                 Align    [2]float32
28035                                 Offset   [2]float32
28036                                 WorldPos Pos
28037                                 Size     [2]int32
28038                                 ZIndex   int16
28039                                 Text2    string
28040                                 Style    HUDStyleFlags
28041                         }))(obj)).Offset)[local324]
28042                         *p = math.Float32frombits(read32(r))
28043                 }
28044         }
28045         if err := pcall(func() {
28046                 ((*(*(struct {
28047                         Type HUDType
28048
28049                         Pos      [2]float32
28050                         Name     string
28051                         Scale    [2]float32
28052                         Text     string
28053                         Number   uint32
28054                         Item     uint32
28055                         Dir      uint32
28056                         Align    [2]float32
28057                         Offset   [2]float32
28058                         WorldPos Pos
28059                         Size     [2]int32
28060                         ZIndex   int16
28061                         Text2    string
28062                         Style    HUDStyleFlags
28063                 }))(obj)).WorldPos).Deserialize(r)
28064         }); err != nil {
28065                 if err == io.EOF {
28066                         chk(io.EOF)
28067                 }
28068                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
28069         }
28070         for local325 := range (*(*(struct {
28071                 Type HUDType
28072
28073                 Pos      [2]float32
28074                 Name     string
28075                 Scale    [2]float32
28076                 Text     string
28077                 Number   uint32
28078                 Item     uint32
28079                 Dir      uint32
28080                 Align    [2]float32
28081                 Offset   [2]float32
28082                 WorldPos Pos
28083                 Size     [2]int32
28084                 ZIndex   int16
28085                 Text2    string
28086                 Style    HUDStyleFlags
28087         }))(obj)).Size {
28088                 {
28089                         p := &((*(*(struct {
28090                                 Type HUDType
28091
28092                                 Pos      [2]float32
28093                                 Name     string
28094                                 Scale    [2]float32
28095                                 Text     string
28096                                 Number   uint32
28097                                 Item     uint32
28098                                 Dir      uint32
28099                                 Align    [2]float32
28100                                 Offset   [2]float32
28101                                 WorldPos Pos
28102                                 Size     [2]int32
28103                                 ZIndex   int16
28104                                 Text2    string
28105                                 Style    HUDStyleFlags
28106                         }))(obj)).Size)[local325]
28107                         *p = int32(read32(r))
28108                 }
28109         }
28110         {
28111                 p := &(*(*(struct {
28112                         Type HUDType
28113
28114                         Pos      [2]float32
28115                         Name     string
28116                         Scale    [2]float32
28117                         Text     string
28118                         Number   uint32
28119                         Item     uint32
28120                         Dir      uint32
28121                         Align    [2]float32
28122                         Offset   [2]float32
28123                         WorldPos Pos
28124                         Size     [2]int32
28125                         ZIndex   int16
28126                         Text2    string
28127                         Style    HUDStyleFlags
28128                 }))(obj)).ZIndex
28129                 *p = int16(read16(r))
28130         }
28131         var local326 []uint8
28132         var local327 uint16
28133         {
28134                 p := &local327
28135                 *p = read16(r)
28136         }
28137         (local326) = make([]uint8, local327)
28138         {
28139                 _, err := io.ReadFull(r, (local326)[:])
28140                 chk(err)
28141         }
28142         ((*(*(struct {
28143                 Type HUDType
28144
28145                 Pos      [2]float32
28146                 Name     string
28147                 Scale    [2]float32
28148                 Text     string
28149                 Number   uint32
28150                 Item     uint32
28151                 Dir      uint32
28152                 Align    [2]float32
28153                 Offset   [2]float32
28154                 WorldPos Pos
28155                 Size     [2]int32
28156                 ZIndex   int16
28157                 Text2    string
28158                 Style    HUDStyleFlags
28159         }))(obj)).Text2) = string(local326)
28160         if err := pcall(func() {
28161                 ((*(*(struct {
28162                         Type HUDType
28163
28164                         Pos      [2]float32
28165                         Name     string
28166                         Scale    [2]float32
28167                         Text     string
28168                         Number   uint32
28169                         Item     uint32
28170                         Dir      uint32
28171                         Align    [2]float32
28172                         Offset   [2]float32
28173                         WorldPos Pos
28174                         Size     [2]int32
28175                         ZIndex   int16
28176                         Text2    string
28177                         Style    HUDStyleFlags
28178                 }))(obj)).Style).Deserialize(r)
28179         }); err != nil {
28180                 if err == io.EOF {
28181                         chk(io.EOF)
28182                 }
28183                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
28184         }
28185 }
28186
28187 func (obj *HUDField) Serialize(w io.Writer) {
28188         {
28189                 x := *(*(uint8))(obj)
28190                 write8(w, uint8(x))
28191         }
28192 }
28193
28194 func (obj *HUDField) Deserialize(r io.Reader) {
28195         {
28196                 p := &*(*(uint8))(obj)
28197                 *p = read8(r)
28198         }
28199 }
28200
28201 func (obj *HUDStyleFlags) Serialize(w io.Writer) {
28202         {
28203                 x := *(*(uint32))(obj)
28204                 write32(w, uint32(x))
28205         }
28206 }
28207
28208 func (obj *HUDStyleFlags) Deserialize(r io.Reader) {
28209         {
28210                 p := &*(*(uint32))(obj)
28211                 *p = read32(r)
28212         }
28213 }
28214
28215 func (obj *HUDFlags) Serialize(w io.Writer) {
28216         {
28217                 x := *(*(uint32))(obj)
28218                 write32(w, uint32(x))
28219         }
28220 }
28221
28222 func (obj *HUDFlags) Deserialize(r io.Reader) {
28223         {
28224                 p := &*(*(uint32))(obj)
28225                 *p = read32(r)
28226         }
28227 }
28228
28229 func (obj *HotbarParam) Serialize(w io.Writer) {
28230         {
28231                 x := *(*(uint16))(obj)
28232                 write16(w, uint16(x))
28233         }
28234 }
28235
28236 func (obj *HotbarParam) Deserialize(r io.Reader) {
28237         {
28238                 p := &*(*(uint16))(obj)
28239                 *p = read16(r)
28240         }
28241 }
28242
28243 func (obj *Texture) Serialize(w io.Writer) {
28244         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
28245                 chk(ErrTooLong)
28246         }
28247         {
28248                 x := uint16(len(([]byte(*(*(string))(obj)))))
28249                 write16(w, uint16(x))
28250         }
28251         {
28252                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
28253                 chk(err)
28254         }
28255 }
28256
28257 func (obj *Texture) Deserialize(r io.Reader) {
28258         var local328 []uint8
28259         var local329 uint16
28260         {
28261                 p := &local329
28262                 *p = read16(r)
28263         }
28264         (local328) = make([]uint8, local329)
28265         {
28266                 _, err := io.ReadFull(r, (local328)[:])
28267                 chk(err)
28268         }
28269         (*(*(string))(obj)) = string(local328)
28270 }
28271
28272 func (obj *PlayerListUpdateType) Serialize(w io.Writer) {
28273         {
28274                 x := *(*(uint8))(obj)
28275                 write8(w, uint8(x))
28276         }
28277 }
28278
28279 func (obj *PlayerListUpdateType) Deserialize(r io.Reader) {
28280         {
28281                 p := &*(*(uint8))(obj)
28282                 *p = read8(r)
28283         }
28284 }
28285
28286 func (obj *ModChanSig) Serialize(w io.Writer) {
28287         {
28288                 x := *(*(uint8))(obj)
28289                 write8(w, uint8(x))
28290         }
28291 }
28292
28293 func (obj *ModChanSig) Deserialize(r io.Reader) {
28294         {
28295                 p := &*(*(uint8))(obj)
28296                 *p = read8(r)
28297         }
28298 }
28299
28300 func (obj *AOProps) Serialize(w io.Writer) {
28301         {
28302                 local330 := uint8(4)
28303                 {
28304                         x := local330
28305                         write8(w, uint8(x))
28306                 }
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)).MaxHP
28345                 write16(w, uint16(x))
28346         }
28347         {
28348                 x := (*(*(struct {
28349                         MaxHP            uint16 // Player only.
28350                         CollideWithNodes bool
28351                         Weight           float32 // deprecated
28352                         ColBox, SelBox   Box
28353                         Pointable        bool
28354                         Visual           string
28355                         VisualSize       [3]float32
28356                         Textures         []Texture
28357                         SpriteSheetSize  [2]int16 // in sprites.
28358                         SpritePos        [2]int16 // in sprite sheet.
28359                         Visible          bool
28360                         MakeFootstepSnds bool
28361                         RotateSpeed      float32 // in radians per second.
28362                         Mesh             string
28363                         Colors           []color.NRGBA
28364                         CollideWithAOs   bool
28365                         StepHeight       float32
28366                         FaceRotateDir    bool
28367                         FaceRotateDirOff float32 // in degrees.
28368                         BackfaceCull     bool
28369                         Nametag          string
28370                         NametagColor     color.NRGBA
28371                         FaceRotateSpeed  float32 // in degrees per second.
28372                         Infotext         string
28373                         Itemstring       string
28374                         Glow             int8
28375                         MaxBreath        uint16  // Player only.
28376                         EyeHeight        float32 // Player only.
28377                         ZoomFOV          float32 // in degrees. Player only.
28378                         UseTextureAlpha  bool
28379                         DmgTextureMod    Texture // suffix
28380                         Shaded           bool
28381                         ShowOnMinimap    bool
28382                         NametagBG        color.NRGBA
28383                 }))(obj)).CollideWithNodes
28384                 if x {
28385                         write8(w, 1)
28386                 } else {
28387                         write8(w, 0)
28388                 }
28389         }
28390         {
28391                 x := (*(*(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)).Weight
28427                 write32(w, math.Float32bits(x))
28428         }
28429         if err := pcall(func() {
28430                 ((*(*(struct {
28431                         MaxHP            uint16 // Player only.
28432                         CollideWithNodes bool
28433                         Weight           float32 // deprecated
28434                         ColBox, SelBox   Box
28435                         Pointable        bool
28436                         Visual           string
28437                         VisualSize       [3]float32
28438                         Textures         []Texture
28439                         SpriteSheetSize  [2]int16 // in sprites.
28440                         SpritePos        [2]int16 // in sprite sheet.
28441                         Visible          bool
28442                         MakeFootstepSnds bool
28443                         RotateSpeed      float32 // in radians per second.
28444                         Mesh             string
28445                         Colors           []color.NRGBA
28446                         CollideWithAOs   bool
28447                         StepHeight       float32
28448                         FaceRotateDir    bool
28449                         FaceRotateDirOff float32 // in degrees.
28450                         BackfaceCull     bool
28451                         Nametag          string
28452                         NametagColor     color.NRGBA
28453                         FaceRotateSpeed  float32 // in degrees per second.
28454                         Infotext         string
28455                         Itemstring       string
28456                         Glow             int8
28457                         MaxBreath        uint16  // Player only.
28458                         EyeHeight        float32 // Player only.
28459                         ZoomFOV          float32 // in degrees. Player only.
28460                         UseTextureAlpha  bool
28461                         DmgTextureMod    Texture // suffix
28462                         Shaded           bool
28463                         ShowOnMinimap    bool
28464                         NametagBG        color.NRGBA
28465                 }))(obj)).ColBox).Serialize(w)
28466         }); err != nil {
28467                 if err == io.EOF {
28468                         chk(io.EOF)
28469                 }
28470                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
28471         }
28472         if err := pcall(func() {
28473                 ((*(*(struct {
28474                         MaxHP            uint16 // Player only.
28475                         CollideWithNodes bool
28476                         Weight           float32 // deprecated
28477                         ColBox, SelBox   Box
28478                         Pointable        bool
28479                         Visual           string
28480                         VisualSize       [3]float32
28481                         Textures         []Texture
28482                         SpriteSheetSize  [2]int16 // in sprites.
28483                         SpritePos        [2]int16 // in sprite sheet.
28484                         Visible          bool
28485                         MakeFootstepSnds bool
28486                         RotateSpeed      float32 // in radians per second.
28487                         Mesh             string
28488                         Colors           []color.NRGBA
28489                         CollideWithAOs   bool
28490                         StepHeight       float32
28491                         FaceRotateDir    bool
28492                         FaceRotateDirOff float32 // in degrees.
28493                         BackfaceCull     bool
28494                         Nametag          string
28495                         NametagColor     color.NRGBA
28496                         FaceRotateSpeed  float32 // in degrees per second.
28497                         Infotext         string
28498                         Itemstring       string
28499                         Glow             int8
28500                         MaxBreath        uint16  // Player only.
28501                         EyeHeight        float32 // Player only.
28502                         ZoomFOV          float32 // in degrees. Player only.
28503                         UseTextureAlpha  bool
28504                         DmgTextureMod    Texture // suffix
28505                         Shaded           bool
28506                         ShowOnMinimap    bool
28507                         NametagBG        color.NRGBA
28508                 }))(obj)).SelBox).Serialize(w)
28509         }); err != nil {
28510                 if err == io.EOF {
28511                         chk(io.EOF)
28512                 }
28513                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
28514         }
28515         {
28516                 x := (*(*(struct {
28517                         MaxHP            uint16 // Player only.
28518                         CollideWithNodes bool
28519                         Weight           float32 // deprecated
28520                         ColBox, SelBox   Box
28521                         Pointable        bool
28522                         Visual           string
28523                         VisualSize       [3]float32
28524                         Textures         []Texture
28525                         SpriteSheetSize  [2]int16 // in sprites.
28526                         SpritePos        [2]int16 // in sprite sheet.
28527                         Visible          bool
28528                         MakeFootstepSnds bool
28529                         RotateSpeed      float32 // in radians per second.
28530                         Mesh             string
28531                         Colors           []color.NRGBA
28532                         CollideWithAOs   bool
28533                         StepHeight       float32
28534                         FaceRotateDir    bool
28535                         FaceRotateDirOff float32 // in degrees.
28536                         BackfaceCull     bool
28537                         Nametag          string
28538                         NametagColor     color.NRGBA
28539                         FaceRotateSpeed  float32 // in degrees per second.
28540                         Infotext         string
28541                         Itemstring       string
28542                         Glow             int8
28543                         MaxBreath        uint16  // Player only.
28544                         EyeHeight        float32 // Player only.
28545                         ZoomFOV          float32 // in degrees. Player only.
28546                         UseTextureAlpha  bool
28547                         DmgTextureMod    Texture // suffix
28548                         Shaded           bool
28549                         ShowOnMinimap    bool
28550                         NametagBG        color.NRGBA
28551                 }))(obj)).Pointable
28552                 if x {
28553                         write8(w, 1)
28554                 } else {
28555                         write8(w, 0)
28556                 }
28557         }
28558         if 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))) > math.MaxUint16 {
28594                 chk(ErrTooLong)
28595         }
28596         {
28597                 x := uint16(len(([]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                 write16(w, uint16(x))
28634         }
28635         {
28636                 _, err := w.Write(([]byte((*(*(struct {
28637                         MaxHP            uint16 // Player only.
28638                         CollideWithNodes bool
28639                         Weight           float32 // deprecated
28640                         ColBox, SelBox   Box
28641                         Pointable        bool
28642                         Visual           string
28643                         VisualSize       [3]float32
28644                         Textures         []Texture
28645                         SpriteSheetSize  [2]int16 // in sprites.
28646                         SpritePos        [2]int16 // in sprite sheet.
28647                         Visible          bool
28648                         MakeFootstepSnds bool
28649                         RotateSpeed      float32 // in radians per second.
28650                         Mesh             string
28651                         Colors           []color.NRGBA
28652                         CollideWithAOs   bool
28653                         StepHeight       float32
28654                         FaceRotateDir    bool
28655                         FaceRotateDirOff float32 // in degrees.
28656                         BackfaceCull     bool
28657                         Nametag          string
28658                         NametagColor     color.NRGBA
28659                         FaceRotateSpeed  float32 // in degrees per second.
28660                         Infotext         string
28661                         Itemstring       string
28662                         Glow             int8
28663                         MaxBreath        uint16  // Player only.
28664                         EyeHeight        float32 // Player only.
28665                         ZoomFOV          float32 // in degrees. Player only.
28666                         UseTextureAlpha  bool
28667                         DmgTextureMod    Texture // suffix
28668                         Shaded           bool
28669                         ShowOnMinimap    bool
28670                         NametagBG        color.NRGBA
28671                 }))(obj)).Visual))[:])
28672                 chk(err)
28673         }
28674         for local331 := range (*(*(struct {
28675                 MaxHP            uint16 // Player only.
28676                 CollideWithNodes bool
28677                 Weight           float32 // deprecated
28678                 ColBox, SelBox   Box
28679                 Pointable        bool
28680                 Visual           string
28681                 VisualSize       [3]float32
28682                 Textures         []Texture
28683                 SpriteSheetSize  [2]int16 // in sprites.
28684                 SpritePos        [2]int16 // in sprite sheet.
28685                 Visible          bool
28686                 MakeFootstepSnds bool
28687                 RotateSpeed      float32 // in radians per second.
28688                 Mesh             string
28689                 Colors           []color.NRGBA
28690                 CollideWithAOs   bool
28691                 StepHeight       float32
28692                 FaceRotateDir    bool
28693                 FaceRotateDirOff float32 // in degrees.
28694                 BackfaceCull     bool
28695                 Nametag          string
28696                 NametagColor     color.NRGBA
28697                 FaceRotateSpeed  float32 // in degrees per second.
28698                 Infotext         string
28699                 Itemstring       string
28700                 Glow             int8
28701                 MaxBreath        uint16  // Player only.
28702                 EyeHeight        float32 // Player only.
28703                 ZoomFOV          float32 // in degrees. Player only.
28704                 UseTextureAlpha  bool
28705                 DmgTextureMod    Texture // suffix
28706                 Shaded           bool
28707                 ShowOnMinimap    bool
28708                 NametagBG        color.NRGBA
28709         }))(obj)).VisualSize {
28710                 {
28711                         x := ((*(*(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)).VisualSize)[local331]
28747                         write32(w, math.Float32bits(x))
28748                 }
28749         }
28750         if 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)) > math.MaxUint16 {
28786                 chk(ErrTooLong)
28787         }
28788         {
28789                 x := uint16(len(((*(*(struct {
28790                         MaxHP            uint16 // Player only.
28791                         CollideWithNodes bool
28792                         Weight           float32 // deprecated
28793                         ColBox, SelBox   Box
28794                         Pointable        bool
28795                         Visual           string
28796                         VisualSize       [3]float32
28797                         Textures         []Texture
28798                         SpriteSheetSize  [2]int16 // in sprites.
28799                         SpritePos        [2]int16 // in sprite sheet.
28800                         Visible          bool
28801                         MakeFootstepSnds bool
28802                         RotateSpeed      float32 // in radians per second.
28803                         Mesh             string
28804                         Colors           []color.NRGBA
28805                         CollideWithAOs   bool
28806                         StepHeight       float32
28807                         FaceRotateDir    bool
28808                         FaceRotateDirOff float32 // in degrees.
28809                         BackfaceCull     bool
28810                         Nametag          string
28811                         NametagColor     color.NRGBA
28812                         FaceRotateSpeed  float32 // in degrees per second.
28813                         Infotext         string
28814                         Itemstring       string
28815                         Glow             int8
28816                         MaxBreath        uint16  // Player only.
28817                         EyeHeight        float32 // Player only.
28818                         ZoomFOV          float32 // in degrees. Player only.
28819                         UseTextureAlpha  bool
28820                         DmgTextureMod    Texture // suffix
28821                         Shaded           bool
28822                         ShowOnMinimap    bool
28823                         NametagBG        color.NRGBA
28824                 }))(obj)).Textures)))
28825                 write16(w, uint16(x))
28826         }
28827         for local332 := range (*(*(struct {
28828                 MaxHP            uint16 // Player only.
28829                 CollideWithNodes bool
28830                 Weight           float32 // deprecated
28831                 ColBox, SelBox   Box
28832                 Pointable        bool
28833                 Visual           string
28834                 VisualSize       [3]float32
28835                 Textures         []Texture
28836                 SpriteSheetSize  [2]int16 // in sprites.
28837                 SpritePos        [2]int16 // in sprite sheet.
28838                 Visible          bool
28839                 MakeFootstepSnds bool
28840                 RotateSpeed      float32 // in radians per second.
28841                 Mesh             string
28842                 Colors           []color.NRGBA
28843                 CollideWithAOs   bool
28844                 StepHeight       float32
28845                 FaceRotateDir    bool
28846                 FaceRotateDirOff float32 // in degrees.
28847                 BackfaceCull     bool
28848                 Nametag          string
28849                 NametagColor     color.NRGBA
28850                 FaceRotateSpeed  float32 // in degrees per second.
28851                 Infotext         string
28852                 Itemstring       string
28853                 Glow             int8
28854                 MaxBreath        uint16  // Player only.
28855                 EyeHeight        float32 // Player only.
28856                 ZoomFOV          float32 // in degrees. Player only.
28857                 UseTextureAlpha  bool
28858                 DmgTextureMod    Texture // suffix
28859                 Shaded           bool
28860                 ShowOnMinimap    bool
28861                 NametagBG        color.NRGBA
28862         }))(obj)).Textures {
28863                 if err := pcall(func() {
28864                         (((*(*(struct {
28865                                 MaxHP            uint16 // Player only.
28866                                 CollideWithNodes bool
28867                                 Weight           float32 // deprecated
28868                                 ColBox, SelBox   Box
28869                                 Pointable        bool
28870                                 Visual           string
28871                                 VisualSize       [3]float32
28872                                 Textures         []Texture
28873                                 SpriteSheetSize  [2]int16 // in sprites.
28874                                 SpritePos        [2]int16 // in sprite sheet.
28875                                 Visible          bool
28876                                 MakeFootstepSnds bool
28877                                 RotateSpeed      float32 // in radians per second.
28878                                 Mesh             string
28879                                 Colors           []color.NRGBA
28880                                 CollideWithAOs   bool
28881                                 StepHeight       float32
28882                                 FaceRotateDir    bool
28883                                 FaceRotateDirOff float32 // in degrees.
28884                                 BackfaceCull     bool
28885                                 Nametag          string
28886                                 NametagColor     color.NRGBA
28887                                 FaceRotateSpeed  float32 // in degrees per second.
28888                                 Infotext         string
28889                                 Itemstring       string
28890                                 Glow             int8
28891                                 MaxBreath        uint16  // Player only.
28892                                 EyeHeight        float32 // Player only.
28893                                 ZoomFOV          float32 // in degrees. Player only.
28894                                 UseTextureAlpha  bool
28895                                 DmgTextureMod    Texture // suffix
28896                                 Shaded           bool
28897                                 ShowOnMinimap    bool
28898                                 NametagBG        color.NRGBA
28899                         }))(obj)).Textures)[local332]).Serialize(w)
28900                 }); err != nil {
28901                         if err == io.EOF {
28902                                 chk(io.EOF)
28903                         }
28904                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
28905                 }
28906         }
28907         for local333 := range (*(*(struct {
28908                 MaxHP            uint16 // Player only.
28909                 CollideWithNodes bool
28910                 Weight           float32 // deprecated
28911                 ColBox, SelBox   Box
28912                 Pointable        bool
28913                 Visual           string
28914                 VisualSize       [3]float32
28915                 Textures         []Texture
28916                 SpriteSheetSize  [2]int16 // in sprites.
28917                 SpritePos        [2]int16 // in sprite sheet.
28918                 Visible          bool
28919                 MakeFootstepSnds bool
28920                 RotateSpeed      float32 // in radians per second.
28921                 Mesh             string
28922                 Colors           []color.NRGBA
28923                 CollideWithAOs   bool
28924                 StepHeight       float32
28925                 FaceRotateDir    bool
28926                 FaceRotateDirOff float32 // in degrees.
28927                 BackfaceCull     bool
28928                 Nametag          string
28929                 NametagColor     color.NRGBA
28930                 FaceRotateSpeed  float32 // in degrees per second.
28931                 Infotext         string
28932                 Itemstring       string
28933                 Glow             int8
28934                 MaxBreath        uint16  // Player only.
28935                 EyeHeight        float32 // Player only.
28936                 ZoomFOV          float32 // in degrees. Player only.
28937                 UseTextureAlpha  bool
28938                 DmgTextureMod    Texture // suffix
28939                 Shaded           bool
28940                 ShowOnMinimap    bool
28941                 NametagBG        color.NRGBA
28942         }))(obj)).SpriteSheetSize {
28943                 {
28944                         x := ((*(*(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)).SpriteSheetSize)[local333]
28980                         write16(w, uint16(x))
28981                 }
28982         }
28983         for local334 := range (*(*(struct {
28984                 MaxHP            uint16 // Player only.
28985                 CollideWithNodes bool
28986                 Weight           float32 // deprecated
28987                 ColBox, SelBox   Box
28988                 Pointable        bool
28989                 Visual           string
28990                 VisualSize       [3]float32
28991                 Textures         []Texture
28992                 SpriteSheetSize  [2]int16 // in sprites.
28993                 SpritePos        [2]int16 // in sprite sheet.
28994                 Visible          bool
28995                 MakeFootstepSnds bool
28996                 RotateSpeed      float32 // in radians per second.
28997                 Mesh             string
28998                 Colors           []color.NRGBA
28999                 CollideWithAOs   bool
29000                 StepHeight       float32
29001                 FaceRotateDir    bool
29002                 FaceRotateDirOff float32 // in degrees.
29003                 BackfaceCull     bool
29004                 Nametag          string
29005                 NametagColor     color.NRGBA
29006                 FaceRotateSpeed  float32 // in degrees per second.
29007                 Infotext         string
29008                 Itemstring       string
29009                 Glow             int8
29010                 MaxBreath        uint16  // Player only.
29011                 EyeHeight        float32 // Player only.
29012                 ZoomFOV          float32 // in degrees. Player only.
29013                 UseTextureAlpha  bool
29014                 DmgTextureMod    Texture // suffix
29015                 Shaded           bool
29016                 ShowOnMinimap    bool
29017                 NametagBG        color.NRGBA
29018         }))(obj)).SpritePos {
29019                 {
29020                         x := ((*(*(struct {
29021                                 MaxHP            uint16 // Player only.
29022                                 CollideWithNodes bool
29023                                 Weight           float32 // deprecated
29024                                 ColBox, SelBox   Box
29025                                 Pointable        bool
29026                                 Visual           string
29027                                 VisualSize       [3]float32
29028                                 Textures         []Texture
29029                                 SpriteSheetSize  [2]int16 // in sprites.
29030                                 SpritePos        [2]int16 // in sprite sheet.
29031                                 Visible          bool
29032                                 MakeFootstepSnds bool
29033                                 RotateSpeed      float32 // in radians per second.
29034                                 Mesh             string
29035                                 Colors           []color.NRGBA
29036                                 CollideWithAOs   bool
29037                                 StepHeight       float32
29038                                 FaceRotateDir    bool
29039                                 FaceRotateDirOff float32 // in degrees.
29040                                 BackfaceCull     bool
29041                                 Nametag          string
29042                                 NametagColor     color.NRGBA
29043                                 FaceRotateSpeed  float32 // in degrees per second.
29044                                 Infotext         string
29045                                 Itemstring       string
29046                                 Glow             int8
29047                                 MaxBreath        uint16  // Player only.
29048                                 EyeHeight        float32 // Player only.
29049                                 ZoomFOV          float32 // in degrees. Player only.
29050                                 UseTextureAlpha  bool
29051                                 DmgTextureMod    Texture // suffix
29052                                 Shaded           bool
29053                                 ShowOnMinimap    bool
29054                                 NametagBG        color.NRGBA
29055                         }))(obj)).SpritePos)[local334]
29056                         write16(w, uint16(x))
29057                 }
29058         }
29059         {
29060                 x := (*(*(struct {
29061                         MaxHP            uint16 // Player only.
29062                         CollideWithNodes bool
29063                         Weight           float32 // deprecated
29064                         ColBox, SelBox   Box
29065                         Pointable        bool
29066                         Visual           string
29067                         VisualSize       [3]float32
29068                         Textures         []Texture
29069                         SpriteSheetSize  [2]int16 // in sprites.
29070                         SpritePos        [2]int16 // in sprite sheet.
29071                         Visible          bool
29072                         MakeFootstepSnds bool
29073                         RotateSpeed      float32 // in radians per second.
29074                         Mesh             string
29075                         Colors           []color.NRGBA
29076                         CollideWithAOs   bool
29077                         StepHeight       float32
29078                         FaceRotateDir    bool
29079                         FaceRotateDirOff float32 // in degrees.
29080                         BackfaceCull     bool
29081                         Nametag          string
29082                         NametagColor     color.NRGBA
29083                         FaceRotateSpeed  float32 // in degrees per second.
29084                         Infotext         string
29085                         Itemstring       string
29086                         Glow             int8
29087                         MaxBreath        uint16  // Player only.
29088                         EyeHeight        float32 // Player only.
29089                         ZoomFOV          float32 // in degrees. Player only.
29090                         UseTextureAlpha  bool
29091                         DmgTextureMod    Texture // suffix
29092                         Shaded           bool
29093                         ShowOnMinimap    bool
29094                         NametagBG        color.NRGBA
29095                 }))(obj)).Visible
29096                 if x {
29097                         write8(w, 1)
29098                 } else {
29099                         write8(w, 0)
29100                 }
29101         }
29102         {
29103                 x := (*(*(struct {
29104                         MaxHP            uint16 // Player only.
29105                         CollideWithNodes bool
29106                         Weight           float32 // deprecated
29107                         ColBox, SelBox   Box
29108                         Pointable        bool
29109                         Visual           string
29110                         VisualSize       [3]float32
29111                         Textures         []Texture
29112                         SpriteSheetSize  [2]int16 // in sprites.
29113                         SpritePos        [2]int16 // in sprite sheet.
29114                         Visible          bool
29115                         MakeFootstepSnds bool
29116                         RotateSpeed      float32 // in radians per second.
29117                         Mesh             string
29118                         Colors           []color.NRGBA
29119                         CollideWithAOs   bool
29120                         StepHeight       float32
29121                         FaceRotateDir    bool
29122                         FaceRotateDirOff float32 // in degrees.
29123                         BackfaceCull     bool
29124                         Nametag          string
29125                         NametagColor     color.NRGBA
29126                         FaceRotateSpeed  float32 // in degrees per second.
29127                         Infotext         string
29128                         Itemstring       string
29129                         Glow             int8
29130                         MaxBreath        uint16  // Player only.
29131                         EyeHeight        float32 // Player only.
29132                         ZoomFOV          float32 // in degrees. Player only.
29133                         UseTextureAlpha  bool
29134                         DmgTextureMod    Texture // suffix
29135                         Shaded           bool
29136                         ShowOnMinimap    bool
29137                         NametagBG        color.NRGBA
29138                 }))(obj)).MakeFootstepSnds
29139                 if x {
29140                         write8(w, 1)
29141                 } else {
29142                         write8(w, 0)
29143                 }
29144         }
29145         {
29146                 x := (*(*(struct {
29147                         MaxHP            uint16 // Player only.
29148                         CollideWithNodes bool
29149                         Weight           float32 // deprecated
29150                         ColBox, SelBox   Box
29151                         Pointable        bool
29152                         Visual           string
29153                         VisualSize       [3]float32
29154                         Textures         []Texture
29155                         SpriteSheetSize  [2]int16 // in sprites.
29156                         SpritePos        [2]int16 // in sprite sheet.
29157                         Visible          bool
29158                         MakeFootstepSnds bool
29159                         RotateSpeed      float32 // in radians per second.
29160                         Mesh             string
29161                         Colors           []color.NRGBA
29162                         CollideWithAOs   bool
29163                         StepHeight       float32
29164                         FaceRotateDir    bool
29165                         FaceRotateDirOff float32 // in degrees.
29166                         BackfaceCull     bool
29167                         Nametag          string
29168                         NametagColor     color.NRGBA
29169                         FaceRotateSpeed  float32 // in degrees per second.
29170                         Infotext         string
29171                         Itemstring       string
29172                         Glow             int8
29173                         MaxBreath        uint16  // Player only.
29174                         EyeHeight        float32 // Player only.
29175                         ZoomFOV          float32 // in degrees. Player only.
29176                         UseTextureAlpha  bool
29177                         DmgTextureMod    Texture // suffix
29178                         Shaded           bool
29179                         ShowOnMinimap    bool
29180                         NametagBG        color.NRGBA
29181                 }))(obj)).RotateSpeed
29182                 write32(w, math.Float32bits(x))
29183         }
29184         if 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))) > math.MaxUint16 {
29220                 chk(ErrTooLong)
29221         }
29222         {
29223                 x := uint16(len(([]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                 write16(w, uint16(x))
29260         }
29261         {
29262                 _, err := w.Write(([]byte((*(*(struct {
29263                         MaxHP            uint16 // Player only.
29264                         CollideWithNodes bool
29265                         Weight           float32 // deprecated
29266                         ColBox, SelBox   Box
29267                         Pointable        bool
29268                         Visual           string
29269                         VisualSize       [3]float32
29270                         Textures         []Texture
29271                         SpriteSheetSize  [2]int16 // in sprites.
29272                         SpritePos        [2]int16 // in sprite sheet.
29273                         Visible          bool
29274                         MakeFootstepSnds bool
29275                         RotateSpeed      float32 // in radians per second.
29276                         Mesh             string
29277                         Colors           []color.NRGBA
29278                         CollideWithAOs   bool
29279                         StepHeight       float32
29280                         FaceRotateDir    bool
29281                         FaceRotateDirOff float32 // in degrees.
29282                         BackfaceCull     bool
29283                         Nametag          string
29284                         NametagColor     color.NRGBA
29285                         FaceRotateSpeed  float32 // in degrees per second.
29286                         Infotext         string
29287                         Itemstring       string
29288                         Glow             int8
29289                         MaxBreath        uint16  // Player only.
29290                         EyeHeight        float32 // Player only.
29291                         ZoomFOV          float32 // in degrees. Player only.
29292                         UseTextureAlpha  bool
29293                         DmgTextureMod    Texture // suffix
29294                         Shaded           bool
29295                         ShowOnMinimap    bool
29296                         NametagBG        color.NRGBA
29297                 }))(obj)).Mesh))[:])
29298                 chk(err)
29299         }
29300         if 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)) > math.MaxUint16 {
29336                 chk(ErrTooLong)
29337         }
29338         {
29339                 x := uint16(len(((*(*(struct {
29340                         MaxHP            uint16 // Player only.
29341                         CollideWithNodes bool
29342                         Weight           float32 // deprecated
29343                         ColBox, SelBox   Box
29344                         Pointable        bool
29345                         Visual           string
29346                         VisualSize       [3]float32
29347                         Textures         []Texture
29348                         SpriteSheetSize  [2]int16 // in sprites.
29349                         SpritePos        [2]int16 // in sprite sheet.
29350                         Visible          bool
29351                         MakeFootstepSnds bool
29352                         RotateSpeed      float32 // in radians per second.
29353                         Mesh             string
29354                         Colors           []color.NRGBA
29355                         CollideWithAOs   bool
29356                         StepHeight       float32
29357                         FaceRotateDir    bool
29358                         FaceRotateDirOff float32 // in degrees.
29359                         BackfaceCull     bool
29360                         Nametag          string
29361                         NametagColor     color.NRGBA
29362                         FaceRotateSpeed  float32 // in degrees per second.
29363                         Infotext         string
29364                         Itemstring       string
29365                         Glow             int8
29366                         MaxBreath        uint16  // Player only.
29367                         EyeHeight        float32 // Player only.
29368                         ZoomFOV          float32 // in degrees. Player only.
29369                         UseTextureAlpha  bool
29370                         DmgTextureMod    Texture // suffix
29371                         Shaded           bool
29372                         ShowOnMinimap    bool
29373                         NametagBG        color.NRGBA
29374                 }))(obj)).Colors)))
29375                 write16(w, uint16(x))
29376         }
29377         for local335 := range (*(*(struct {
29378                 MaxHP            uint16 // Player only.
29379                 CollideWithNodes bool
29380                 Weight           float32 // deprecated
29381                 ColBox, SelBox   Box
29382                 Pointable        bool
29383                 Visual           string
29384                 VisualSize       [3]float32
29385                 Textures         []Texture
29386                 SpriteSheetSize  [2]int16 // in sprites.
29387                 SpritePos        [2]int16 // in sprite sheet.
29388                 Visible          bool
29389                 MakeFootstepSnds bool
29390                 RotateSpeed      float32 // in radians per second.
29391                 Mesh             string
29392                 Colors           []color.NRGBA
29393                 CollideWithAOs   bool
29394                 StepHeight       float32
29395                 FaceRotateDir    bool
29396                 FaceRotateDirOff float32 // in degrees.
29397                 BackfaceCull     bool
29398                 Nametag          string
29399                 NametagColor     color.NRGBA
29400                 FaceRotateSpeed  float32 // in degrees per second.
29401                 Infotext         string
29402                 Itemstring       string
29403                 Glow             int8
29404                 MaxBreath        uint16  // Player only.
29405                 EyeHeight        float32 // Player only.
29406                 ZoomFOV          float32 // in degrees. Player only.
29407                 UseTextureAlpha  bool
29408                 DmgTextureMod    Texture // suffix
29409                 Shaded           bool
29410                 ShowOnMinimap    bool
29411                 NametagBG        color.NRGBA
29412         }))(obj)).Colors {
29413                 {
29414                         x := ((*(*(struct {
29415                                 MaxHP            uint16 // Player only.
29416                                 CollideWithNodes bool
29417                                 Weight           float32 // deprecated
29418                                 ColBox, SelBox   Box
29419                                 Pointable        bool
29420                                 Visual           string
29421                                 VisualSize       [3]float32
29422                                 Textures         []Texture
29423                                 SpriteSheetSize  [2]int16 // in sprites.
29424                                 SpritePos        [2]int16 // in sprite sheet.
29425                                 Visible          bool
29426                                 MakeFootstepSnds bool
29427                                 RotateSpeed      float32 // in radians per second.
29428                                 Mesh             string
29429                                 Colors           []color.NRGBA
29430                                 CollideWithAOs   bool
29431                                 StepHeight       float32
29432                                 FaceRotateDir    bool
29433                                 FaceRotateDirOff float32 // in degrees.
29434                                 BackfaceCull     bool
29435                                 Nametag          string
29436                                 NametagColor     color.NRGBA
29437                                 FaceRotateSpeed  float32 // in degrees per second.
29438                                 Infotext         string
29439                                 Itemstring       string
29440                                 Glow             int8
29441                                 MaxBreath        uint16  // Player only.
29442                                 EyeHeight        float32 // Player only.
29443                                 ZoomFOV          float32 // in degrees. Player only.
29444                                 UseTextureAlpha  bool
29445                                 DmgTextureMod    Texture // suffix
29446                                 Shaded           bool
29447                                 ShowOnMinimap    bool
29448                                 NametagBG        color.NRGBA
29449                         }))(obj)).Colors)[local335]
29450                         w.Write([]byte{x.A, x.R, x.G, x.B})
29451                 }
29452         }
29453         {
29454                 x := (*(*(struct {
29455                         MaxHP            uint16 // Player only.
29456                         CollideWithNodes bool
29457                         Weight           float32 // deprecated
29458                         ColBox, SelBox   Box
29459                         Pointable        bool
29460                         Visual           string
29461                         VisualSize       [3]float32
29462                         Textures         []Texture
29463                         SpriteSheetSize  [2]int16 // in sprites.
29464                         SpritePos        [2]int16 // in sprite sheet.
29465                         Visible          bool
29466                         MakeFootstepSnds bool
29467                         RotateSpeed      float32 // in radians per second.
29468                         Mesh             string
29469                         Colors           []color.NRGBA
29470                         CollideWithAOs   bool
29471                         StepHeight       float32
29472                         FaceRotateDir    bool
29473                         FaceRotateDirOff float32 // in degrees.
29474                         BackfaceCull     bool
29475                         Nametag          string
29476                         NametagColor     color.NRGBA
29477                         FaceRotateSpeed  float32 // in degrees per second.
29478                         Infotext         string
29479                         Itemstring       string
29480                         Glow             int8
29481                         MaxBreath        uint16  // Player only.
29482                         EyeHeight        float32 // Player only.
29483                         ZoomFOV          float32 // in degrees. Player only.
29484                         UseTextureAlpha  bool
29485                         DmgTextureMod    Texture // suffix
29486                         Shaded           bool
29487                         ShowOnMinimap    bool
29488                         NametagBG        color.NRGBA
29489                 }))(obj)).CollideWithAOs
29490                 if x {
29491                         write8(w, 1)
29492                 } else {
29493                         write8(w, 0)
29494                 }
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)).StepHeight
29533                 write32(w, math.Float32bits(x))
29534         }
29535         {
29536                 x := (*(*(struct {
29537                         MaxHP            uint16 // Player only.
29538                         CollideWithNodes bool
29539                         Weight           float32 // deprecated
29540                         ColBox, SelBox   Box
29541                         Pointable        bool
29542                         Visual           string
29543                         VisualSize       [3]float32
29544                         Textures         []Texture
29545                         SpriteSheetSize  [2]int16 // in sprites.
29546                         SpritePos        [2]int16 // in sprite sheet.
29547                         Visible          bool
29548                         MakeFootstepSnds bool
29549                         RotateSpeed      float32 // in radians per second.
29550                         Mesh             string
29551                         Colors           []color.NRGBA
29552                         CollideWithAOs   bool
29553                         StepHeight       float32
29554                         FaceRotateDir    bool
29555                         FaceRotateDirOff float32 // in degrees.
29556                         BackfaceCull     bool
29557                         Nametag          string
29558                         NametagColor     color.NRGBA
29559                         FaceRotateSpeed  float32 // in degrees per second.
29560                         Infotext         string
29561                         Itemstring       string
29562                         Glow             int8
29563                         MaxBreath        uint16  // Player only.
29564                         EyeHeight        float32 // Player only.
29565                         ZoomFOV          float32 // in degrees. Player only.
29566                         UseTextureAlpha  bool
29567                         DmgTextureMod    Texture // suffix
29568                         Shaded           bool
29569                         ShowOnMinimap    bool
29570                         NametagBG        color.NRGBA
29571                 }))(obj)).FaceRotateDir
29572                 if x {
29573                         write8(w, 1)
29574                 } else {
29575                         write8(w, 0)
29576                 }
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)).FaceRotateDirOff
29615                 write32(w, math.Float32bits(x))
29616         }
29617         {
29618                 x := (*(*(struct {
29619                         MaxHP            uint16 // Player only.
29620                         CollideWithNodes bool
29621                         Weight           float32 // deprecated
29622                         ColBox, SelBox   Box
29623                         Pointable        bool
29624                         Visual           string
29625                         VisualSize       [3]float32
29626                         Textures         []Texture
29627                         SpriteSheetSize  [2]int16 // in sprites.
29628                         SpritePos        [2]int16 // in sprite sheet.
29629                         Visible          bool
29630                         MakeFootstepSnds bool
29631                         RotateSpeed      float32 // in radians per second.
29632                         Mesh             string
29633                         Colors           []color.NRGBA
29634                         CollideWithAOs   bool
29635                         StepHeight       float32
29636                         FaceRotateDir    bool
29637                         FaceRotateDirOff float32 // in degrees.
29638                         BackfaceCull     bool
29639                         Nametag          string
29640                         NametagColor     color.NRGBA
29641                         FaceRotateSpeed  float32 // in degrees per second.
29642                         Infotext         string
29643                         Itemstring       string
29644                         Glow             int8
29645                         MaxBreath        uint16  // Player only.
29646                         EyeHeight        float32 // Player only.
29647                         ZoomFOV          float32 // in degrees. Player only.
29648                         UseTextureAlpha  bool
29649                         DmgTextureMod    Texture // suffix
29650                         Shaded           bool
29651                         ShowOnMinimap    bool
29652                         NametagBG        color.NRGBA
29653                 }))(obj)).BackfaceCull
29654                 if x {
29655                         write8(w, 1)
29656                 } else {
29657                         write8(w, 0)
29658                 }
29659         }
29660         if 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))) > math.MaxUint16 {
29696                 chk(ErrTooLong)
29697         }
29698         {
29699                 x := uint16(len(([]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                 write16(w, uint16(x))
29736         }
29737         {
29738                 _, err := w.Write(([]byte((*(*(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)).Nametag))[:])
29774                 chk(err)
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)).NametagColor
29813                 w.Write([]byte{x.A, x.R, x.G, x.B})
29814         }
29815         {
29816                 x := (*(*(struct {
29817                         MaxHP            uint16 // Player only.
29818                         CollideWithNodes bool
29819                         Weight           float32 // deprecated
29820                         ColBox, SelBox   Box
29821                         Pointable        bool
29822                         Visual           string
29823                         VisualSize       [3]float32
29824                         Textures         []Texture
29825                         SpriteSheetSize  [2]int16 // in sprites.
29826                         SpritePos        [2]int16 // in sprite sheet.
29827                         Visible          bool
29828                         MakeFootstepSnds bool
29829                         RotateSpeed      float32 // in radians per second.
29830                         Mesh             string
29831                         Colors           []color.NRGBA
29832                         CollideWithAOs   bool
29833                         StepHeight       float32
29834                         FaceRotateDir    bool
29835                         FaceRotateDirOff float32 // in degrees.
29836                         BackfaceCull     bool
29837                         Nametag          string
29838                         NametagColor     color.NRGBA
29839                         FaceRotateSpeed  float32 // in degrees per second.
29840                         Infotext         string
29841                         Itemstring       string
29842                         Glow             int8
29843                         MaxBreath        uint16  // Player only.
29844                         EyeHeight        float32 // Player only.
29845                         ZoomFOV          float32 // in degrees. Player only.
29846                         UseTextureAlpha  bool
29847                         DmgTextureMod    Texture // suffix
29848                         Shaded           bool
29849                         ShowOnMinimap    bool
29850                         NametagBG        color.NRGBA
29851                 }))(obj)).FaceRotateSpeed
29852                 write32(w, math.Float32bits(x))
29853         }
29854         if 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))) > math.MaxUint16 {
29890                 chk(ErrTooLong)
29891         }
29892         {
29893                 x := uint16(len(([]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                 write16(w, uint16(x))
29930         }
29931         {
29932                 _, err := w.Write(([]byte((*(*(struct {
29933                         MaxHP            uint16 // Player only.
29934                         CollideWithNodes bool
29935                         Weight           float32 // deprecated
29936                         ColBox, SelBox   Box
29937                         Pointable        bool
29938                         Visual           string
29939                         VisualSize       [3]float32
29940                         Textures         []Texture
29941                         SpriteSheetSize  [2]int16 // in sprites.
29942                         SpritePos        [2]int16 // in sprite sheet.
29943                         Visible          bool
29944                         MakeFootstepSnds bool
29945                         RotateSpeed      float32 // in radians per second.
29946                         Mesh             string
29947                         Colors           []color.NRGBA
29948                         CollideWithAOs   bool
29949                         StepHeight       float32
29950                         FaceRotateDir    bool
29951                         FaceRotateDirOff float32 // in degrees.
29952                         BackfaceCull     bool
29953                         Nametag          string
29954                         NametagColor     color.NRGBA
29955                         FaceRotateSpeed  float32 // in degrees per second.
29956                         Infotext         string
29957                         Itemstring       string
29958                         Glow             int8
29959                         MaxBreath        uint16  // Player only.
29960                         EyeHeight        float32 // Player only.
29961                         ZoomFOV          float32 // in degrees. Player only.
29962                         UseTextureAlpha  bool
29963                         DmgTextureMod    Texture // suffix
29964                         Shaded           bool
29965                         ShowOnMinimap    bool
29966                         NametagBG        color.NRGBA
29967                 }))(obj)).Infotext))[:])
29968                 chk(err)
29969         }
29970         if 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))) > math.MaxUint16 {
30006                 chk(ErrTooLong)
30007         }
30008         {
30009                 x := uint16(len(([]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                 write16(w, uint16(x))
30046         }
30047         {
30048                 _, err := w.Write(([]byte((*(*(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)).Itemstring))[:])
30084                 chk(err)
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)).Glow
30123                 write8(w, uint8(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)).MaxBreath
30162                 write16(w, uint16(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)).EyeHeight
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)).ZoomFOV
30240                 write32(w, math.Float32bits(x))
30241         }
30242         {
30243                 x := (*(*(struct {
30244                         MaxHP            uint16 // Player only.
30245                         CollideWithNodes bool
30246                         Weight           float32 // deprecated
30247                         ColBox, SelBox   Box
30248                         Pointable        bool
30249                         Visual           string
30250                         VisualSize       [3]float32
30251                         Textures         []Texture
30252                         SpriteSheetSize  [2]int16 // in sprites.
30253                         SpritePos        [2]int16 // in sprite sheet.
30254                         Visible          bool
30255                         MakeFootstepSnds bool
30256                         RotateSpeed      float32 // in radians per second.
30257                         Mesh             string
30258                         Colors           []color.NRGBA
30259                         CollideWithAOs   bool
30260                         StepHeight       float32
30261                         FaceRotateDir    bool
30262                         FaceRotateDirOff float32 // in degrees.
30263                         BackfaceCull     bool
30264                         Nametag          string
30265                         NametagColor     color.NRGBA
30266                         FaceRotateSpeed  float32 // in degrees per second.
30267                         Infotext         string
30268                         Itemstring       string
30269                         Glow             int8
30270                         MaxBreath        uint16  // Player only.
30271                         EyeHeight        float32 // Player only.
30272                         ZoomFOV          float32 // in degrees. Player only.
30273                         UseTextureAlpha  bool
30274                         DmgTextureMod    Texture // suffix
30275                         Shaded           bool
30276                         ShowOnMinimap    bool
30277                         NametagBG        color.NRGBA
30278                 }))(obj)).UseTextureAlpha
30279                 if x {
30280                         write8(w, 1)
30281                 } else {
30282                         write8(w, 0)
30283                 }
30284         }
30285         if err := pcall(func() {
30286                 ((*(*(struct {
30287                         MaxHP            uint16 // Player only.
30288                         CollideWithNodes bool
30289                         Weight           float32 // deprecated
30290                         ColBox, SelBox   Box
30291                         Pointable        bool
30292                         Visual           string
30293                         VisualSize       [3]float32
30294                         Textures         []Texture
30295                         SpriteSheetSize  [2]int16 // in sprites.
30296                         SpritePos        [2]int16 // in sprite sheet.
30297                         Visible          bool
30298                         MakeFootstepSnds bool
30299                         RotateSpeed      float32 // in radians per second.
30300                         Mesh             string
30301                         Colors           []color.NRGBA
30302                         CollideWithAOs   bool
30303                         StepHeight       float32
30304                         FaceRotateDir    bool
30305                         FaceRotateDirOff float32 // in degrees.
30306                         BackfaceCull     bool
30307                         Nametag          string
30308                         NametagColor     color.NRGBA
30309                         FaceRotateSpeed  float32 // in degrees per second.
30310                         Infotext         string
30311                         Itemstring       string
30312                         Glow             int8
30313                         MaxBreath        uint16  // Player only.
30314                         EyeHeight        float32 // Player only.
30315                         ZoomFOV          float32 // in degrees. Player only.
30316                         UseTextureAlpha  bool
30317                         DmgTextureMod    Texture // suffix
30318                         Shaded           bool
30319                         ShowOnMinimap    bool
30320                         NametagBG        color.NRGBA
30321                 }))(obj)).DmgTextureMod).Serialize(w)
30322         }); err != nil {
30323                 if err == io.EOF {
30324                         chk(io.EOF)
30325                 }
30326                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
30327         }
30328         {
30329                 x := (*(*(struct {
30330                         MaxHP            uint16 // Player only.
30331                         CollideWithNodes bool
30332                         Weight           float32 // deprecated
30333                         ColBox, SelBox   Box
30334                         Pointable        bool
30335                         Visual           string
30336                         VisualSize       [3]float32
30337                         Textures         []Texture
30338                         SpriteSheetSize  [2]int16 // in sprites.
30339                         SpritePos        [2]int16 // in sprite sheet.
30340                         Visible          bool
30341                         MakeFootstepSnds bool
30342                         RotateSpeed      float32 // in radians per second.
30343                         Mesh             string
30344                         Colors           []color.NRGBA
30345                         CollideWithAOs   bool
30346                         StepHeight       float32
30347                         FaceRotateDir    bool
30348                         FaceRotateDirOff float32 // in degrees.
30349                         BackfaceCull     bool
30350                         Nametag          string
30351                         NametagColor     color.NRGBA
30352                         FaceRotateSpeed  float32 // in degrees per second.
30353                         Infotext         string
30354                         Itemstring       string
30355                         Glow             int8
30356                         MaxBreath        uint16  // Player only.
30357                         EyeHeight        float32 // Player only.
30358                         ZoomFOV          float32 // in degrees. Player only.
30359                         UseTextureAlpha  bool
30360                         DmgTextureMod    Texture // suffix
30361                         Shaded           bool
30362                         ShowOnMinimap    bool
30363                         NametagBG        color.NRGBA
30364                 }))(obj)).Shaded
30365                 if x {
30366                         write8(w, 1)
30367                 } else {
30368                         write8(w, 0)
30369                 }
30370         }
30371         {
30372                 x := (*(*(struct {
30373                         MaxHP            uint16 // Player only.
30374                         CollideWithNodes bool
30375                         Weight           float32 // deprecated
30376                         ColBox, SelBox   Box
30377                         Pointable        bool
30378                         Visual           string
30379                         VisualSize       [3]float32
30380                         Textures         []Texture
30381                         SpriteSheetSize  [2]int16 // in sprites.
30382                         SpritePos        [2]int16 // in sprite sheet.
30383                         Visible          bool
30384                         MakeFootstepSnds bool
30385                         RotateSpeed      float32 // in radians per second.
30386                         Mesh             string
30387                         Colors           []color.NRGBA
30388                         CollideWithAOs   bool
30389                         StepHeight       float32
30390                         FaceRotateDir    bool
30391                         FaceRotateDirOff float32 // in degrees.
30392                         BackfaceCull     bool
30393                         Nametag          string
30394                         NametagColor     color.NRGBA
30395                         FaceRotateSpeed  float32 // in degrees per second.
30396                         Infotext         string
30397                         Itemstring       string
30398                         Glow             int8
30399                         MaxBreath        uint16  // Player only.
30400                         EyeHeight        float32 // Player only.
30401                         ZoomFOV          float32 // in degrees. Player only.
30402                         UseTextureAlpha  bool
30403                         DmgTextureMod    Texture // suffix
30404                         Shaded           bool
30405                         ShowOnMinimap    bool
30406                         NametagBG        color.NRGBA
30407                 }))(obj)).ShowOnMinimap
30408                 if x {
30409                         write8(w, 1)
30410                 } else {
30411                         write8(w, 0)
30412                 }
30413         }
30414         {
30415                 x := (*(*(struct {
30416                         MaxHP            uint16 // Player only.
30417                         CollideWithNodes bool
30418                         Weight           float32 // deprecated
30419                         ColBox, SelBox   Box
30420                         Pointable        bool
30421                         Visual           string
30422                         VisualSize       [3]float32
30423                         Textures         []Texture
30424                         SpriteSheetSize  [2]int16 // in sprites.
30425                         SpritePos        [2]int16 // in sprite sheet.
30426                         Visible          bool
30427                         MakeFootstepSnds bool
30428                         RotateSpeed      float32 // in radians per second.
30429                         Mesh             string
30430                         Colors           []color.NRGBA
30431                         CollideWithAOs   bool
30432                         StepHeight       float32
30433                         FaceRotateDir    bool
30434                         FaceRotateDirOff float32 // in degrees.
30435                         BackfaceCull     bool
30436                         Nametag          string
30437                         NametagColor     color.NRGBA
30438                         FaceRotateSpeed  float32 // in degrees per second.
30439                         Infotext         string
30440                         Itemstring       string
30441                         Glow             int8
30442                         MaxBreath        uint16  // Player only.
30443                         EyeHeight        float32 // Player only.
30444                         ZoomFOV          float32 // in degrees. Player only.
30445                         UseTextureAlpha  bool
30446                         DmgTextureMod    Texture // suffix
30447                         Shaded           bool
30448                         ShowOnMinimap    bool
30449                         NametagBG        color.NRGBA
30450                 }))(obj)).NametagBG
30451                 w.Write([]byte{x.A, x.R, x.G, x.B})
30452         }
30453 }
30454
30455 func (obj *AOProps) Deserialize(r io.Reader) {
30456         {
30457                 var local336 uint8
30458                 local337 := uint8(4)
30459                 {
30460                         p := &local336
30461                         *p = read8(r)
30462                 }
30463                 if local336 != local337 {
30464                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local336))
30465                 }
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)).MaxHP
30504                 *p = read16(r)
30505         }
30506         {
30507                 p := &(*(*(struct {
30508                         MaxHP            uint16 // Player only.
30509                         CollideWithNodes bool
30510                         Weight           float32 // deprecated
30511                         ColBox, SelBox   Box
30512                         Pointable        bool
30513                         Visual           string
30514                         VisualSize       [3]float32
30515                         Textures         []Texture
30516                         SpriteSheetSize  [2]int16 // in sprites.
30517                         SpritePos        [2]int16 // in sprite sheet.
30518                         Visible          bool
30519                         MakeFootstepSnds bool
30520                         RotateSpeed      float32 // in radians per second.
30521                         Mesh             string
30522                         Colors           []color.NRGBA
30523                         CollideWithAOs   bool
30524                         StepHeight       float32
30525                         FaceRotateDir    bool
30526                         FaceRotateDirOff float32 // in degrees.
30527                         BackfaceCull     bool
30528                         Nametag          string
30529                         NametagColor     color.NRGBA
30530                         FaceRotateSpeed  float32 // in degrees per second.
30531                         Infotext         string
30532                         Itemstring       string
30533                         Glow             int8
30534                         MaxBreath        uint16  // Player only.
30535                         EyeHeight        float32 // Player only.
30536                         ZoomFOV          float32 // in degrees. Player only.
30537                         UseTextureAlpha  bool
30538                         DmgTextureMod    Texture // suffix
30539                         Shaded           bool
30540                         ShowOnMinimap    bool
30541                         NametagBG        color.NRGBA
30542                 }))(obj)).CollideWithNodes
30543                 switch n := read8(r); n {
30544                 case 0:
30545                         *p = false
30546                 case 1:
30547                         *p = true
30548                 default:
30549                         chk(fmt.Errorf("invalid bool: %d", n))
30550                 }
30551         }
30552         {
30553                 p := &(*(*(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)).Weight
30589                 *p = math.Float32frombits(read32(r))
30590         }
30591         if err := pcall(func() {
30592                 ((*(*(struct {
30593                         MaxHP            uint16 // Player only.
30594                         CollideWithNodes bool
30595                         Weight           float32 // deprecated
30596                         ColBox, SelBox   Box
30597                         Pointable        bool
30598                         Visual           string
30599                         VisualSize       [3]float32
30600                         Textures         []Texture
30601                         SpriteSheetSize  [2]int16 // in sprites.
30602                         SpritePos        [2]int16 // in sprite sheet.
30603                         Visible          bool
30604                         MakeFootstepSnds bool
30605                         RotateSpeed      float32 // in radians per second.
30606                         Mesh             string
30607                         Colors           []color.NRGBA
30608                         CollideWithAOs   bool
30609                         StepHeight       float32
30610                         FaceRotateDir    bool
30611                         FaceRotateDirOff float32 // in degrees.
30612                         BackfaceCull     bool
30613                         Nametag          string
30614                         NametagColor     color.NRGBA
30615                         FaceRotateSpeed  float32 // in degrees per second.
30616                         Infotext         string
30617                         Itemstring       string
30618                         Glow             int8
30619                         MaxBreath        uint16  // Player only.
30620                         EyeHeight        float32 // Player only.
30621                         ZoomFOV          float32 // in degrees. Player only.
30622                         UseTextureAlpha  bool
30623                         DmgTextureMod    Texture // suffix
30624                         Shaded           bool
30625                         ShowOnMinimap    bool
30626                         NametagBG        color.NRGBA
30627                 }))(obj)).ColBox).Deserialize(r)
30628         }); err != nil {
30629                 if err == io.EOF {
30630                         chk(io.EOF)
30631                 }
30632                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
30633         }
30634         if err := pcall(func() {
30635                 ((*(*(struct {
30636                         MaxHP            uint16 // Player only.
30637                         CollideWithNodes bool
30638                         Weight           float32 // deprecated
30639                         ColBox, SelBox   Box
30640                         Pointable        bool
30641                         Visual           string
30642                         VisualSize       [3]float32
30643                         Textures         []Texture
30644                         SpriteSheetSize  [2]int16 // in sprites.
30645                         SpritePos        [2]int16 // in sprite sheet.
30646                         Visible          bool
30647                         MakeFootstepSnds bool
30648                         RotateSpeed      float32 // in radians per second.
30649                         Mesh             string
30650                         Colors           []color.NRGBA
30651                         CollideWithAOs   bool
30652                         StepHeight       float32
30653                         FaceRotateDir    bool
30654                         FaceRotateDirOff float32 // in degrees.
30655                         BackfaceCull     bool
30656                         Nametag          string
30657                         NametagColor     color.NRGBA
30658                         FaceRotateSpeed  float32 // in degrees per second.
30659                         Infotext         string
30660                         Itemstring       string
30661                         Glow             int8
30662                         MaxBreath        uint16  // Player only.
30663                         EyeHeight        float32 // Player only.
30664                         ZoomFOV          float32 // in degrees. Player only.
30665                         UseTextureAlpha  bool
30666                         DmgTextureMod    Texture // suffix
30667                         Shaded           bool
30668                         ShowOnMinimap    bool
30669                         NametagBG        color.NRGBA
30670                 }))(obj)).SelBox).Deserialize(r)
30671         }); err != nil {
30672                 if err == io.EOF {
30673                         chk(io.EOF)
30674                 }
30675                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
30676         }
30677         {
30678                 p := &(*(*(struct {
30679                         MaxHP            uint16 // Player only.
30680                         CollideWithNodes bool
30681                         Weight           float32 // deprecated
30682                         ColBox, SelBox   Box
30683                         Pointable        bool
30684                         Visual           string
30685                         VisualSize       [3]float32
30686                         Textures         []Texture
30687                         SpriteSheetSize  [2]int16 // in sprites.
30688                         SpritePos        [2]int16 // in sprite sheet.
30689                         Visible          bool
30690                         MakeFootstepSnds bool
30691                         RotateSpeed      float32 // in radians per second.
30692                         Mesh             string
30693                         Colors           []color.NRGBA
30694                         CollideWithAOs   bool
30695                         StepHeight       float32
30696                         FaceRotateDir    bool
30697                         FaceRotateDirOff float32 // in degrees.
30698                         BackfaceCull     bool
30699                         Nametag          string
30700                         NametagColor     color.NRGBA
30701                         FaceRotateSpeed  float32 // in degrees per second.
30702                         Infotext         string
30703                         Itemstring       string
30704                         Glow             int8
30705                         MaxBreath        uint16  // Player only.
30706                         EyeHeight        float32 // Player only.
30707                         ZoomFOV          float32 // in degrees. Player only.
30708                         UseTextureAlpha  bool
30709                         DmgTextureMod    Texture // suffix
30710                         Shaded           bool
30711                         ShowOnMinimap    bool
30712                         NametagBG        color.NRGBA
30713                 }))(obj)).Pointable
30714                 switch n := read8(r); n {
30715                 case 0:
30716                         *p = false
30717                 case 1:
30718                         *p = true
30719                 default:
30720                         chk(fmt.Errorf("invalid bool: %d", n))
30721                 }
30722         }
30723         var local338 []uint8
30724         var local339 uint16
30725         {
30726                 p := &local339
30727                 *p = read16(r)
30728         }
30729         (local338) = make([]uint8, local339)
30730         {
30731                 _, err := io.ReadFull(r, (local338)[:])
30732                 chk(err)
30733         }
30734         ((*(*(struct {
30735                 MaxHP            uint16 // Player only.
30736                 CollideWithNodes bool
30737                 Weight           float32 // deprecated
30738                 ColBox, SelBox   Box
30739                 Pointable        bool
30740                 Visual           string
30741                 VisualSize       [3]float32
30742                 Textures         []Texture
30743                 SpriteSheetSize  [2]int16 // in sprites.
30744                 SpritePos        [2]int16 // in sprite sheet.
30745                 Visible          bool
30746                 MakeFootstepSnds bool
30747                 RotateSpeed      float32 // in radians per second.
30748                 Mesh             string
30749                 Colors           []color.NRGBA
30750                 CollideWithAOs   bool
30751                 StepHeight       float32
30752                 FaceRotateDir    bool
30753                 FaceRotateDirOff float32 // in degrees.
30754                 BackfaceCull     bool
30755                 Nametag          string
30756                 NametagColor     color.NRGBA
30757                 FaceRotateSpeed  float32 // in degrees per second.
30758                 Infotext         string
30759                 Itemstring       string
30760                 Glow             int8
30761                 MaxBreath        uint16  // Player only.
30762                 EyeHeight        float32 // Player only.
30763                 ZoomFOV          float32 // in degrees. Player only.
30764                 UseTextureAlpha  bool
30765                 DmgTextureMod    Texture // suffix
30766                 Shaded           bool
30767                 ShowOnMinimap    bool
30768                 NametagBG        color.NRGBA
30769         }))(obj)).Visual) = string(local338)
30770         for local340 := range (*(*(struct {
30771                 MaxHP            uint16 // Player only.
30772                 CollideWithNodes bool
30773                 Weight           float32 // deprecated
30774                 ColBox, SelBox   Box
30775                 Pointable        bool
30776                 Visual           string
30777                 VisualSize       [3]float32
30778                 Textures         []Texture
30779                 SpriteSheetSize  [2]int16 // in sprites.
30780                 SpritePos        [2]int16 // in sprite sheet.
30781                 Visible          bool
30782                 MakeFootstepSnds bool
30783                 RotateSpeed      float32 // in radians per second.
30784                 Mesh             string
30785                 Colors           []color.NRGBA
30786                 CollideWithAOs   bool
30787                 StepHeight       float32
30788                 FaceRotateDir    bool
30789                 FaceRotateDirOff float32 // in degrees.
30790                 BackfaceCull     bool
30791                 Nametag          string
30792                 NametagColor     color.NRGBA
30793                 FaceRotateSpeed  float32 // in degrees per second.
30794                 Infotext         string
30795                 Itemstring       string
30796                 Glow             int8
30797                 MaxBreath        uint16  // Player only.
30798                 EyeHeight        float32 // Player only.
30799                 ZoomFOV          float32 // in degrees. Player only.
30800                 UseTextureAlpha  bool
30801                 DmgTextureMod    Texture // suffix
30802                 Shaded           bool
30803                 ShowOnMinimap    bool
30804                 NametagBG        color.NRGBA
30805         }))(obj)).VisualSize {
30806                 {
30807                         p := &((*(*(struct {
30808                                 MaxHP            uint16 // Player only.
30809                                 CollideWithNodes bool
30810                                 Weight           float32 // deprecated
30811                                 ColBox, SelBox   Box
30812                                 Pointable        bool
30813                                 Visual           string
30814                                 VisualSize       [3]float32
30815                                 Textures         []Texture
30816                                 SpriteSheetSize  [2]int16 // in sprites.
30817                                 SpritePos        [2]int16 // in sprite sheet.
30818                                 Visible          bool
30819                                 MakeFootstepSnds bool
30820                                 RotateSpeed      float32 // in radians per second.
30821                                 Mesh             string
30822                                 Colors           []color.NRGBA
30823                                 CollideWithAOs   bool
30824                                 StepHeight       float32
30825                                 FaceRotateDir    bool
30826                                 FaceRotateDirOff float32 // in degrees.
30827                                 BackfaceCull     bool
30828                                 Nametag          string
30829                                 NametagColor     color.NRGBA
30830                                 FaceRotateSpeed  float32 // in degrees per second.
30831                                 Infotext         string
30832                                 Itemstring       string
30833                                 Glow             int8
30834                                 MaxBreath        uint16  // Player only.
30835                                 EyeHeight        float32 // Player only.
30836                                 ZoomFOV          float32 // in degrees. Player only.
30837                                 UseTextureAlpha  bool
30838                                 DmgTextureMod    Texture // suffix
30839                                 Shaded           bool
30840                                 ShowOnMinimap    bool
30841                                 NametagBG        color.NRGBA
30842                         }))(obj)).VisualSize)[local340]
30843                         *p = math.Float32frombits(read32(r))
30844                 }
30845         }
30846         var local341 uint16
30847         {
30848                 p := &local341
30849                 *p = read16(r)
30850         }
30851         ((*(*(struct {
30852                 MaxHP            uint16 // Player only.
30853                 CollideWithNodes bool
30854                 Weight           float32 // deprecated
30855                 ColBox, SelBox   Box
30856                 Pointable        bool
30857                 Visual           string
30858                 VisualSize       [3]float32
30859                 Textures         []Texture
30860                 SpriteSheetSize  [2]int16 // in sprites.
30861                 SpritePos        [2]int16 // in sprite sheet.
30862                 Visible          bool
30863                 MakeFootstepSnds bool
30864                 RotateSpeed      float32 // in radians per second.
30865                 Mesh             string
30866                 Colors           []color.NRGBA
30867                 CollideWithAOs   bool
30868                 StepHeight       float32
30869                 FaceRotateDir    bool
30870                 FaceRotateDirOff float32 // in degrees.
30871                 BackfaceCull     bool
30872                 Nametag          string
30873                 NametagColor     color.NRGBA
30874                 FaceRotateSpeed  float32 // in degrees per second.
30875                 Infotext         string
30876                 Itemstring       string
30877                 Glow             int8
30878                 MaxBreath        uint16  // Player only.
30879                 EyeHeight        float32 // Player only.
30880                 ZoomFOV          float32 // in degrees. Player only.
30881                 UseTextureAlpha  bool
30882                 DmgTextureMod    Texture // suffix
30883                 Shaded           bool
30884                 ShowOnMinimap    bool
30885                 NametagBG        color.NRGBA
30886         }))(obj)).Textures) = make([]Texture, local341)
30887         for local342 := range (*(*(struct {
30888                 MaxHP            uint16 // Player only.
30889                 CollideWithNodes bool
30890                 Weight           float32 // deprecated
30891                 ColBox, SelBox   Box
30892                 Pointable        bool
30893                 Visual           string
30894                 VisualSize       [3]float32
30895                 Textures         []Texture
30896                 SpriteSheetSize  [2]int16 // in sprites.
30897                 SpritePos        [2]int16 // in sprite sheet.
30898                 Visible          bool
30899                 MakeFootstepSnds bool
30900                 RotateSpeed      float32 // in radians per second.
30901                 Mesh             string
30902                 Colors           []color.NRGBA
30903                 CollideWithAOs   bool
30904                 StepHeight       float32
30905                 FaceRotateDir    bool
30906                 FaceRotateDirOff float32 // in degrees.
30907                 BackfaceCull     bool
30908                 Nametag          string
30909                 NametagColor     color.NRGBA
30910                 FaceRotateSpeed  float32 // in degrees per second.
30911                 Infotext         string
30912                 Itemstring       string
30913                 Glow             int8
30914                 MaxBreath        uint16  // Player only.
30915                 EyeHeight        float32 // Player only.
30916                 ZoomFOV          float32 // in degrees. Player only.
30917                 UseTextureAlpha  bool
30918                 DmgTextureMod    Texture // suffix
30919                 Shaded           bool
30920                 ShowOnMinimap    bool
30921                 NametagBG        color.NRGBA
30922         }))(obj)).Textures {
30923                 if err := pcall(func() {
30924                         (((*(*(struct {
30925                                 MaxHP            uint16 // Player only.
30926                                 CollideWithNodes bool
30927                                 Weight           float32 // deprecated
30928                                 ColBox, SelBox   Box
30929                                 Pointable        bool
30930                                 Visual           string
30931                                 VisualSize       [3]float32
30932                                 Textures         []Texture
30933                                 SpriteSheetSize  [2]int16 // in sprites.
30934                                 SpritePos        [2]int16 // in sprite sheet.
30935                                 Visible          bool
30936                                 MakeFootstepSnds bool
30937                                 RotateSpeed      float32 // in radians per second.
30938                                 Mesh             string
30939                                 Colors           []color.NRGBA
30940                                 CollideWithAOs   bool
30941                                 StepHeight       float32
30942                                 FaceRotateDir    bool
30943                                 FaceRotateDirOff float32 // in degrees.
30944                                 BackfaceCull     bool
30945                                 Nametag          string
30946                                 NametagColor     color.NRGBA
30947                                 FaceRotateSpeed  float32 // in degrees per second.
30948                                 Infotext         string
30949                                 Itemstring       string
30950                                 Glow             int8
30951                                 MaxBreath        uint16  // Player only.
30952                                 EyeHeight        float32 // Player only.
30953                                 ZoomFOV          float32 // in degrees. Player only.
30954                                 UseTextureAlpha  bool
30955                                 DmgTextureMod    Texture // suffix
30956                                 Shaded           bool
30957                                 ShowOnMinimap    bool
30958                                 NametagBG        color.NRGBA
30959                         }))(obj)).Textures)[local342]).Deserialize(r)
30960                 }); err != nil {
30961                         if err == io.EOF {
30962                                 chk(io.EOF)
30963                         }
30964                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
30965                 }
30966         }
30967         for local343 := range (*(*(struct {
30968                 MaxHP            uint16 // Player only.
30969                 CollideWithNodes bool
30970                 Weight           float32 // deprecated
30971                 ColBox, SelBox   Box
30972                 Pointable        bool
30973                 Visual           string
30974                 VisualSize       [3]float32
30975                 Textures         []Texture
30976                 SpriteSheetSize  [2]int16 // in sprites.
30977                 SpritePos        [2]int16 // in sprite sheet.
30978                 Visible          bool
30979                 MakeFootstepSnds bool
30980                 RotateSpeed      float32 // in radians per second.
30981                 Mesh             string
30982                 Colors           []color.NRGBA
30983                 CollideWithAOs   bool
30984                 StepHeight       float32
30985                 FaceRotateDir    bool
30986                 FaceRotateDirOff float32 // in degrees.
30987                 BackfaceCull     bool
30988                 Nametag          string
30989                 NametagColor     color.NRGBA
30990                 FaceRotateSpeed  float32 // in degrees per second.
30991                 Infotext         string
30992                 Itemstring       string
30993                 Glow             int8
30994                 MaxBreath        uint16  // Player only.
30995                 EyeHeight        float32 // Player only.
30996                 ZoomFOV          float32 // in degrees. Player only.
30997                 UseTextureAlpha  bool
30998                 DmgTextureMod    Texture // suffix
30999                 Shaded           bool
31000                 ShowOnMinimap    bool
31001                 NametagBG        color.NRGBA
31002         }))(obj)).SpriteSheetSize {
31003                 {
31004                         p := &((*(*(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)).SpriteSheetSize)[local343]
31040                         *p = int16(read16(r))
31041                 }
31042         }
31043         for local344 := range (*(*(struct {
31044                 MaxHP            uint16 // Player only.
31045                 CollideWithNodes bool
31046                 Weight           float32 // deprecated
31047                 ColBox, SelBox   Box
31048                 Pointable        bool
31049                 Visual           string
31050                 VisualSize       [3]float32
31051                 Textures         []Texture
31052                 SpriteSheetSize  [2]int16 // in sprites.
31053                 SpritePos        [2]int16 // in sprite sheet.
31054                 Visible          bool
31055                 MakeFootstepSnds bool
31056                 RotateSpeed      float32 // in radians per second.
31057                 Mesh             string
31058                 Colors           []color.NRGBA
31059                 CollideWithAOs   bool
31060                 StepHeight       float32
31061                 FaceRotateDir    bool
31062                 FaceRotateDirOff float32 // in degrees.
31063                 BackfaceCull     bool
31064                 Nametag          string
31065                 NametagColor     color.NRGBA
31066                 FaceRotateSpeed  float32 // in degrees per second.
31067                 Infotext         string
31068                 Itemstring       string
31069                 Glow             int8
31070                 MaxBreath        uint16  // Player only.
31071                 EyeHeight        float32 // Player only.
31072                 ZoomFOV          float32 // in degrees. Player only.
31073                 UseTextureAlpha  bool
31074                 DmgTextureMod    Texture // suffix
31075                 Shaded           bool
31076                 ShowOnMinimap    bool
31077                 NametagBG        color.NRGBA
31078         }))(obj)).SpritePos {
31079                 {
31080                         p := &((*(*(struct {
31081                                 MaxHP            uint16 // Player only.
31082                                 CollideWithNodes bool
31083                                 Weight           float32 // deprecated
31084                                 ColBox, SelBox   Box
31085                                 Pointable        bool
31086                                 Visual           string
31087                                 VisualSize       [3]float32
31088                                 Textures         []Texture
31089                                 SpriteSheetSize  [2]int16 // in sprites.
31090                                 SpritePos        [2]int16 // in sprite sheet.
31091                                 Visible          bool
31092                                 MakeFootstepSnds bool
31093                                 RotateSpeed      float32 // in radians per second.
31094                                 Mesh             string
31095                                 Colors           []color.NRGBA
31096                                 CollideWithAOs   bool
31097                                 StepHeight       float32
31098                                 FaceRotateDir    bool
31099                                 FaceRotateDirOff float32 // in degrees.
31100                                 BackfaceCull     bool
31101                                 Nametag          string
31102                                 NametagColor     color.NRGBA
31103                                 FaceRotateSpeed  float32 // in degrees per second.
31104                                 Infotext         string
31105                                 Itemstring       string
31106                                 Glow             int8
31107                                 MaxBreath        uint16  // Player only.
31108                                 EyeHeight        float32 // Player only.
31109                                 ZoomFOV          float32 // in degrees. Player only.
31110                                 UseTextureAlpha  bool
31111                                 DmgTextureMod    Texture // suffix
31112                                 Shaded           bool
31113                                 ShowOnMinimap    bool
31114                                 NametagBG        color.NRGBA
31115                         }))(obj)).SpritePos)[local344]
31116                         *p = int16(read16(r))
31117                 }
31118         }
31119         {
31120                 p := &(*(*(struct {
31121                         MaxHP            uint16 // Player only.
31122                         CollideWithNodes bool
31123                         Weight           float32 // deprecated
31124                         ColBox, SelBox   Box
31125                         Pointable        bool
31126                         Visual           string
31127                         VisualSize       [3]float32
31128                         Textures         []Texture
31129                         SpriteSheetSize  [2]int16 // in sprites.
31130                         SpritePos        [2]int16 // in sprite sheet.
31131                         Visible          bool
31132                         MakeFootstepSnds bool
31133                         RotateSpeed      float32 // in radians per second.
31134                         Mesh             string
31135                         Colors           []color.NRGBA
31136                         CollideWithAOs   bool
31137                         StepHeight       float32
31138                         FaceRotateDir    bool
31139                         FaceRotateDirOff float32 // in degrees.
31140                         BackfaceCull     bool
31141                         Nametag          string
31142                         NametagColor     color.NRGBA
31143                         FaceRotateSpeed  float32 // in degrees per second.
31144                         Infotext         string
31145                         Itemstring       string
31146                         Glow             int8
31147                         MaxBreath        uint16  // Player only.
31148                         EyeHeight        float32 // Player only.
31149                         ZoomFOV          float32 // in degrees. Player only.
31150                         UseTextureAlpha  bool
31151                         DmgTextureMod    Texture // suffix
31152                         Shaded           bool
31153                         ShowOnMinimap    bool
31154                         NametagBG        color.NRGBA
31155                 }))(obj)).Visible
31156                 switch n := read8(r); n {
31157                 case 0:
31158                         *p = false
31159                 case 1:
31160                         *p = true
31161                 default:
31162                         chk(fmt.Errorf("invalid bool: %d", n))
31163                 }
31164         }
31165         {
31166                 p := &(*(*(struct {
31167                         MaxHP            uint16 // Player only.
31168                         CollideWithNodes bool
31169                         Weight           float32 // deprecated
31170                         ColBox, SelBox   Box
31171                         Pointable        bool
31172                         Visual           string
31173                         VisualSize       [3]float32
31174                         Textures         []Texture
31175                         SpriteSheetSize  [2]int16 // in sprites.
31176                         SpritePos        [2]int16 // in sprite sheet.
31177                         Visible          bool
31178                         MakeFootstepSnds bool
31179                         RotateSpeed      float32 // in radians per second.
31180                         Mesh             string
31181                         Colors           []color.NRGBA
31182                         CollideWithAOs   bool
31183                         StepHeight       float32
31184                         FaceRotateDir    bool
31185                         FaceRotateDirOff float32 // in degrees.
31186                         BackfaceCull     bool
31187                         Nametag          string
31188                         NametagColor     color.NRGBA
31189                         FaceRotateSpeed  float32 // in degrees per second.
31190                         Infotext         string
31191                         Itemstring       string
31192                         Glow             int8
31193                         MaxBreath        uint16  // Player only.
31194                         EyeHeight        float32 // Player only.
31195                         ZoomFOV          float32 // in degrees. Player only.
31196                         UseTextureAlpha  bool
31197                         DmgTextureMod    Texture // suffix
31198                         Shaded           bool
31199                         ShowOnMinimap    bool
31200                         NametagBG        color.NRGBA
31201                 }))(obj)).MakeFootstepSnds
31202                 switch n := read8(r); n {
31203                 case 0:
31204                         *p = false
31205                 case 1:
31206                         *p = true
31207                 default:
31208                         chk(fmt.Errorf("invalid bool: %d", n))
31209                 }
31210         }
31211         {
31212                 p := &(*(*(struct {
31213                         MaxHP            uint16 // Player only.
31214                         CollideWithNodes bool
31215                         Weight           float32 // deprecated
31216                         ColBox, SelBox   Box
31217                         Pointable        bool
31218                         Visual           string
31219                         VisualSize       [3]float32
31220                         Textures         []Texture
31221                         SpriteSheetSize  [2]int16 // in sprites.
31222                         SpritePos        [2]int16 // in sprite sheet.
31223                         Visible          bool
31224                         MakeFootstepSnds bool
31225                         RotateSpeed      float32 // in radians per second.
31226                         Mesh             string
31227                         Colors           []color.NRGBA
31228                         CollideWithAOs   bool
31229                         StepHeight       float32
31230                         FaceRotateDir    bool
31231                         FaceRotateDirOff float32 // in degrees.
31232                         BackfaceCull     bool
31233                         Nametag          string
31234                         NametagColor     color.NRGBA
31235                         FaceRotateSpeed  float32 // in degrees per second.
31236                         Infotext         string
31237                         Itemstring       string
31238                         Glow             int8
31239                         MaxBreath        uint16  // Player only.
31240                         EyeHeight        float32 // Player only.
31241                         ZoomFOV          float32 // in degrees. Player only.
31242                         UseTextureAlpha  bool
31243                         DmgTextureMod    Texture // suffix
31244                         Shaded           bool
31245                         ShowOnMinimap    bool
31246                         NametagBG        color.NRGBA
31247                 }))(obj)).RotateSpeed
31248                 *p = math.Float32frombits(read32(r))
31249         }
31250         var local345 []uint8
31251         var local346 uint16
31252         {
31253                 p := &local346
31254                 *p = read16(r)
31255         }
31256         (local345) = make([]uint8, local346)
31257         {
31258                 _, err := io.ReadFull(r, (local345)[:])
31259                 chk(err)
31260         }
31261         ((*(*(struct {
31262                 MaxHP            uint16 // Player only.
31263                 CollideWithNodes bool
31264                 Weight           float32 // deprecated
31265                 ColBox, SelBox   Box
31266                 Pointable        bool
31267                 Visual           string
31268                 VisualSize       [3]float32
31269                 Textures         []Texture
31270                 SpriteSheetSize  [2]int16 // in sprites.
31271                 SpritePos        [2]int16 // in sprite sheet.
31272                 Visible          bool
31273                 MakeFootstepSnds bool
31274                 RotateSpeed      float32 // in radians per second.
31275                 Mesh             string
31276                 Colors           []color.NRGBA
31277                 CollideWithAOs   bool
31278                 StepHeight       float32
31279                 FaceRotateDir    bool
31280                 FaceRotateDirOff float32 // in degrees.
31281                 BackfaceCull     bool
31282                 Nametag          string
31283                 NametagColor     color.NRGBA
31284                 FaceRotateSpeed  float32 // in degrees per second.
31285                 Infotext         string
31286                 Itemstring       string
31287                 Glow             int8
31288                 MaxBreath        uint16  // Player only.
31289                 EyeHeight        float32 // Player only.
31290                 ZoomFOV          float32 // in degrees. Player only.
31291                 UseTextureAlpha  bool
31292                 DmgTextureMod    Texture // suffix
31293                 Shaded           bool
31294                 ShowOnMinimap    bool
31295                 NametagBG        color.NRGBA
31296         }))(obj)).Mesh) = string(local345)
31297         var local347 uint16
31298         {
31299                 p := &local347
31300                 *p = read16(r)
31301         }
31302         ((*(*(struct {
31303                 MaxHP            uint16 // Player only.
31304                 CollideWithNodes bool
31305                 Weight           float32 // deprecated
31306                 ColBox, SelBox   Box
31307                 Pointable        bool
31308                 Visual           string
31309                 VisualSize       [3]float32
31310                 Textures         []Texture
31311                 SpriteSheetSize  [2]int16 // in sprites.
31312                 SpritePos        [2]int16 // in sprite sheet.
31313                 Visible          bool
31314                 MakeFootstepSnds bool
31315                 RotateSpeed      float32 // in radians per second.
31316                 Mesh             string
31317                 Colors           []color.NRGBA
31318                 CollideWithAOs   bool
31319                 StepHeight       float32
31320                 FaceRotateDir    bool
31321                 FaceRotateDirOff float32 // in degrees.
31322                 BackfaceCull     bool
31323                 Nametag          string
31324                 NametagColor     color.NRGBA
31325                 FaceRotateSpeed  float32 // in degrees per second.
31326                 Infotext         string
31327                 Itemstring       string
31328                 Glow             int8
31329                 MaxBreath        uint16  // Player only.
31330                 EyeHeight        float32 // Player only.
31331                 ZoomFOV          float32 // in degrees. Player only.
31332                 UseTextureAlpha  bool
31333                 DmgTextureMod    Texture // suffix
31334                 Shaded           bool
31335                 ShowOnMinimap    bool
31336                 NametagBG        color.NRGBA
31337         }))(obj)).Colors) = make([]color.NRGBA, local347)
31338         for local348 := range (*(*(struct {
31339                 MaxHP            uint16 // Player only.
31340                 CollideWithNodes bool
31341                 Weight           float32 // deprecated
31342                 ColBox, SelBox   Box
31343                 Pointable        bool
31344                 Visual           string
31345                 VisualSize       [3]float32
31346                 Textures         []Texture
31347                 SpriteSheetSize  [2]int16 // in sprites.
31348                 SpritePos        [2]int16 // in sprite sheet.
31349                 Visible          bool
31350                 MakeFootstepSnds bool
31351                 RotateSpeed      float32 // in radians per second.
31352                 Mesh             string
31353                 Colors           []color.NRGBA
31354                 CollideWithAOs   bool
31355                 StepHeight       float32
31356                 FaceRotateDir    bool
31357                 FaceRotateDirOff float32 // in degrees.
31358                 BackfaceCull     bool
31359                 Nametag          string
31360                 NametagColor     color.NRGBA
31361                 FaceRotateSpeed  float32 // in degrees per second.
31362                 Infotext         string
31363                 Itemstring       string
31364                 Glow             int8
31365                 MaxBreath        uint16  // Player only.
31366                 EyeHeight        float32 // Player only.
31367                 ZoomFOV          float32 // in degrees. Player only.
31368                 UseTextureAlpha  bool
31369                 DmgTextureMod    Texture // suffix
31370                 Shaded           bool
31371                 ShowOnMinimap    bool
31372                 NametagBG        color.NRGBA
31373         }))(obj)).Colors {
31374                 {
31375                         p := &((*(*(struct {
31376                                 MaxHP            uint16 // Player only.
31377                                 CollideWithNodes bool
31378                                 Weight           float32 // deprecated
31379                                 ColBox, SelBox   Box
31380                                 Pointable        bool
31381                                 Visual           string
31382                                 VisualSize       [3]float32
31383                                 Textures         []Texture
31384                                 SpriteSheetSize  [2]int16 // in sprites.
31385                                 SpritePos        [2]int16 // in sprite sheet.
31386                                 Visible          bool
31387                                 MakeFootstepSnds bool
31388                                 RotateSpeed      float32 // in radians per second.
31389                                 Mesh             string
31390                                 Colors           []color.NRGBA
31391                                 CollideWithAOs   bool
31392                                 StepHeight       float32
31393                                 FaceRotateDir    bool
31394                                 FaceRotateDirOff float32 // in degrees.
31395                                 BackfaceCull     bool
31396                                 Nametag          string
31397                                 NametagColor     color.NRGBA
31398                                 FaceRotateSpeed  float32 // in degrees per second.
31399                                 Infotext         string
31400                                 Itemstring       string
31401                                 Glow             int8
31402                                 MaxBreath        uint16  // Player only.
31403                                 EyeHeight        float32 // Player only.
31404                                 ZoomFOV          float32 // in degrees. Player only.
31405                                 UseTextureAlpha  bool
31406                                 DmgTextureMod    Texture // suffix
31407                                 Shaded           bool
31408                                 ShowOnMinimap    bool
31409                                 NametagBG        color.NRGBA
31410                         }))(obj)).Colors)[local348]
31411                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31412                 }
31413         }
31414         {
31415                 p := &(*(*(struct {
31416                         MaxHP            uint16 // Player only.
31417                         CollideWithNodes bool
31418                         Weight           float32 // deprecated
31419                         ColBox, SelBox   Box
31420                         Pointable        bool
31421                         Visual           string
31422                         VisualSize       [3]float32
31423                         Textures         []Texture
31424                         SpriteSheetSize  [2]int16 // in sprites.
31425                         SpritePos        [2]int16 // in sprite sheet.
31426                         Visible          bool
31427                         MakeFootstepSnds bool
31428                         RotateSpeed      float32 // in radians per second.
31429                         Mesh             string
31430                         Colors           []color.NRGBA
31431                         CollideWithAOs   bool
31432                         StepHeight       float32
31433                         FaceRotateDir    bool
31434                         FaceRotateDirOff float32 // in degrees.
31435                         BackfaceCull     bool
31436                         Nametag          string
31437                         NametagColor     color.NRGBA
31438                         FaceRotateSpeed  float32 // in degrees per second.
31439                         Infotext         string
31440                         Itemstring       string
31441                         Glow             int8
31442                         MaxBreath        uint16  // Player only.
31443                         EyeHeight        float32 // Player only.
31444                         ZoomFOV          float32 // in degrees. Player only.
31445                         UseTextureAlpha  bool
31446                         DmgTextureMod    Texture // suffix
31447                         Shaded           bool
31448                         ShowOnMinimap    bool
31449                         NametagBG        color.NRGBA
31450                 }))(obj)).CollideWithAOs
31451                 switch n := read8(r); n {
31452                 case 0:
31453                         *p = false
31454                 case 1:
31455                         *p = true
31456                 default:
31457                         chk(fmt.Errorf("invalid bool: %d", n))
31458                 }
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)).StepHeight
31497                 *p = math.Float32frombits(read32(r))
31498         }
31499         {
31500                 p := &(*(*(struct {
31501                         MaxHP            uint16 // Player only.
31502                         CollideWithNodes bool
31503                         Weight           float32 // deprecated
31504                         ColBox, SelBox   Box
31505                         Pointable        bool
31506                         Visual           string
31507                         VisualSize       [3]float32
31508                         Textures         []Texture
31509                         SpriteSheetSize  [2]int16 // in sprites.
31510                         SpritePos        [2]int16 // in sprite sheet.
31511                         Visible          bool
31512                         MakeFootstepSnds bool
31513                         RotateSpeed      float32 // in radians per second.
31514                         Mesh             string
31515                         Colors           []color.NRGBA
31516                         CollideWithAOs   bool
31517                         StepHeight       float32
31518                         FaceRotateDir    bool
31519                         FaceRotateDirOff float32 // in degrees.
31520                         BackfaceCull     bool
31521                         Nametag          string
31522                         NametagColor     color.NRGBA
31523                         FaceRotateSpeed  float32 // in degrees per second.
31524                         Infotext         string
31525                         Itemstring       string
31526                         Glow             int8
31527                         MaxBreath        uint16  // Player only.
31528                         EyeHeight        float32 // Player only.
31529                         ZoomFOV          float32 // in degrees. Player only.
31530                         UseTextureAlpha  bool
31531                         DmgTextureMod    Texture // suffix
31532                         Shaded           bool
31533                         ShowOnMinimap    bool
31534                         NametagBG        color.NRGBA
31535                 }))(obj)).FaceRotateDir
31536                 switch n := read8(r); n {
31537                 case 0:
31538                         *p = false
31539                 case 1:
31540                         *p = true
31541                 default:
31542                         chk(fmt.Errorf("invalid bool: %d", n))
31543                 }
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)).FaceRotateDirOff
31582                 *p = math.Float32frombits(read32(r))
31583         }
31584         {
31585                 p := &(*(*(struct {
31586                         MaxHP            uint16 // Player only.
31587                         CollideWithNodes bool
31588                         Weight           float32 // deprecated
31589                         ColBox, SelBox   Box
31590                         Pointable        bool
31591                         Visual           string
31592                         VisualSize       [3]float32
31593                         Textures         []Texture
31594                         SpriteSheetSize  [2]int16 // in sprites.
31595                         SpritePos        [2]int16 // in sprite sheet.
31596                         Visible          bool
31597                         MakeFootstepSnds bool
31598                         RotateSpeed      float32 // in radians per second.
31599                         Mesh             string
31600                         Colors           []color.NRGBA
31601                         CollideWithAOs   bool
31602                         StepHeight       float32
31603                         FaceRotateDir    bool
31604                         FaceRotateDirOff float32 // in degrees.
31605                         BackfaceCull     bool
31606                         Nametag          string
31607                         NametagColor     color.NRGBA
31608                         FaceRotateSpeed  float32 // in degrees per second.
31609                         Infotext         string
31610                         Itemstring       string
31611                         Glow             int8
31612                         MaxBreath        uint16  // Player only.
31613                         EyeHeight        float32 // Player only.
31614                         ZoomFOV          float32 // in degrees. Player only.
31615                         UseTextureAlpha  bool
31616                         DmgTextureMod    Texture // suffix
31617                         Shaded           bool
31618                         ShowOnMinimap    bool
31619                         NametagBG        color.NRGBA
31620                 }))(obj)).BackfaceCull
31621                 switch n := read8(r); n {
31622                 case 0:
31623                         *p = false
31624                 case 1:
31625                         *p = true
31626                 default:
31627                         chk(fmt.Errorf("invalid bool: %d", n))
31628                 }
31629         }
31630         var local349 []uint8
31631         var local350 uint16
31632         {
31633                 p := &local350
31634                 *p = read16(r)
31635         }
31636         (local349) = make([]uint8, local350)
31637         {
31638                 _, err := io.ReadFull(r, (local349)[:])
31639                 chk(err)
31640         }
31641         ((*(*(struct {
31642                 MaxHP            uint16 // Player only.
31643                 CollideWithNodes bool
31644                 Weight           float32 // deprecated
31645                 ColBox, SelBox   Box
31646                 Pointable        bool
31647                 Visual           string
31648                 VisualSize       [3]float32
31649                 Textures         []Texture
31650                 SpriteSheetSize  [2]int16 // in sprites.
31651                 SpritePos        [2]int16 // in sprite sheet.
31652                 Visible          bool
31653                 MakeFootstepSnds bool
31654                 RotateSpeed      float32 // in radians per second.
31655                 Mesh             string
31656                 Colors           []color.NRGBA
31657                 CollideWithAOs   bool
31658                 StepHeight       float32
31659                 FaceRotateDir    bool
31660                 FaceRotateDirOff float32 // in degrees.
31661                 BackfaceCull     bool
31662                 Nametag          string
31663                 NametagColor     color.NRGBA
31664                 FaceRotateSpeed  float32 // in degrees per second.
31665                 Infotext         string
31666                 Itemstring       string
31667                 Glow             int8
31668                 MaxBreath        uint16  // Player only.
31669                 EyeHeight        float32 // Player only.
31670                 ZoomFOV          float32 // in degrees. Player only.
31671                 UseTextureAlpha  bool
31672                 DmgTextureMod    Texture // suffix
31673                 Shaded           bool
31674                 ShowOnMinimap    bool
31675                 NametagBG        color.NRGBA
31676         }))(obj)).Nametag) = string(local349)
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)).NametagColor
31714                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31715         }
31716         {
31717                 p := &(*(*(struct {
31718                         MaxHP            uint16 // Player only.
31719                         CollideWithNodes bool
31720                         Weight           float32 // deprecated
31721                         ColBox, SelBox   Box
31722                         Pointable        bool
31723                         Visual           string
31724                         VisualSize       [3]float32
31725                         Textures         []Texture
31726                         SpriteSheetSize  [2]int16 // in sprites.
31727                         SpritePos        [2]int16 // in sprite sheet.
31728                         Visible          bool
31729                         MakeFootstepSnds bool
31730                         RotateSpeed      float32 // in radians per second.
31731                         Mesh             string
31732                         Colors           []color.NRGBA
31733                         CollideWithAOs   bool
31734                         StepHeight       float32
31735                         FaceRotateDir    bool
31736                         FaceRotateDirOff float32 // in degrees.
31737                         BackfaceCull     bool
31738                         Nametag          string
31739                         NametagColor     color.NRGBA
31740                         FaceRotateSpeed  float32 // in degrees per second.
31741                         Infotext         string
31742                         Itemstring       string
31743                         Glow             int8
31744                         MaxBreath        uint16  // Player only.
31745                         EyeHeight        float32 // Player only.
31746                         ZoomFOV          float32 // in degrees. Player only.
31747                         UseTextureAlpha  bool
31748                         DmgTextureMod    Texture // suffix
31749                         Shaded           bool
31750                         ShowOnMinimap    bool
31751                         NametagBG        color.NRGBA
31752                 }))(obj)).FaceRotateSpeed
31753                 *p = math.Float32frombits(read32(r))
31754         }
31755         var local351 []uint8
31756         var local352 uint16
31757         {
31758                 p := &local352
31759                 *p = read16(r)
31760         }
31761         (local351) = make([]uint8, local352)
31762         {
31763                 _, err := io.ReadFull(r, (local351)[:])
31764                 chk(err)
31765         }
31766         ((*(*(struct {
31767                 MaxHP            uint16 // Player only.
31768                 CollideWithNodes bool
31769                 Weight           float32 // deprecated
31770                 ColBox, SelBox   Box
31771                 Pointable        bool
31772                 Visual           string
31773                 VisualSize       [3]float32
31774                 Textures         []Texture
31775                 SpriteSheetSize  [2]int16 // in sprites.
31776                 SpritePos        [2]int16 // in sprite sheet.
31777                 Visible          bool
31778                 MakeFootstepSnds bool
31779                 RotateSpeed      float32 // in radians per second.
31780                 Mesh             string
31781                 Colors           []color.NRGBA
31782                 CollideWithAOs   bool
31783                 StepHeight       float32
31784                 FaceRotateDir    bool
31785                 FaceRotateDirOff float32 // in degrees.
31786                 BackfaceCull     bool
31787                 Nametag          string
31788                 NametagColor     color.NRGBA
31789                 FaceRotateSpeed  float32 // in degrees per second.
31790                 Infotext         string
31791                 Itemstring       string
31792                 Glow             int8
31793                 MaxBreath        uint16  // Player only.
31794                 EyeHeight        float32 // Player only.
31795                 ZoomFOV          float32 // in degrees. Player only.
31796                 UseTextureAlpha  bool
31797                 DmgTextureMod    Texture // suffix
31798                 Shaded           bool
31799                 ShowOnMinimap    bool
31800                 NametagBG        color.NRGBA
31801         }))(obj)).Infotext) = string(local351)
31802         var local353 []uint8
31803         var local354 uint16
31804         {
31805                 p := &local354
31806                 *p = read16(r)
31807         }
31808         (local353) = make([]uint8, local354)
31809         {
31810                 _, err := io.ReadFull(r, (local353)[:])
31811                 chk(err)
31812         }
31813         ((*(*(struct {
31814                 MaxHP            uint16 // Player only.
31815                 CollideWithNodes bool
31816                 Weight           float32 // deprecated
31817                 ColBox, SelBox   Box
31818                 Pointable        bool
31819                 Visual           string
31820                 VisualSize       [3]float32
31821                 Textures         []Texture
31822                 SpriteSheetSize  [2]int16 // in sprites.
31823                 SpritePos        [2]int16 // in sprite sheet.
31824                 Visible          bool
31825                 MakeFootstepSnds bool
31826                 RotateSpeed      float32 // in radians per second.
31827                 Mesh             string
31828                 Colors           []color.NRGBA
31829                 CollideWithAOs   bool
31830                 StepHeight       float32
31831                 FaceRotateDir    bool
31832                 FaceRotateDirOff float32 // in degrees.
31833                 BackfaceCull     bool
31834                 Nametag          string
31835                 NametagColor     color.NRGBA
31836                 FaceRotateSpeed  float32 // in degrees per second.
31837                 Infotext         string
31838                 Itemstring       string
31839                 Glow             int8
31840                 MaxBreath        uint16  // Player only.
31841                 EyeHeight        float32 // Player only.
31842                 ZoomFOV          float32 // in degrees. Player only.
31843                 UseTextureAlpha  bool
31844                 DmgTextureMod    Texture // suffix
31845                 Shaded           bool
31846                 ShowOnMinimap    bool
31847                 NametagBG        color.NRGBA
31848         }))(obj)).Itemstring) = string(local353)
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)).Glow
31886                 *p = int8(read8(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)).MaxBreath
31925                 *p = read16(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)).EyeHeight
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)).ZoomFOV
32003                 *p = math.Float32frombits(read32(r))
32004         }
32005         {
32006                 p := &(*(*(struct {
32007                         MaxHP            uint16 // Player only.
32008                         CollideWithNodes bool
32009                         Weight           float32 // deprecated
32010                         ColBox, SelBox   Box
32011                         Pointable        bool
32012                         Visual           string
32013                         VisualSize       [3]float32
32014                         Textures         []Texture
32015                         SpriteSheetSize  [2]int16 // in sprites.
32016                         SpritePos        [2]int16 // in sprite sheet.
32017                         Visible          bool
32018                         MakeFootstepSnds bool
32019                         RotateSpeed      float32 // in radians per second.
32020                         Mesh             string
32021                         Colors           []color.NRGBA
32022                         CollideWithAOs   bool
32023                         StepHeight       float32
32024                         FaceRotateDir    bool
32025                         FaceRotateDirOff float32 // in degrees.
32026                         BackfaceCull     bool
32027                         Nametag          string
32028                         NametagColor     color.NRGBA
32029                         FaceRotateSpeed  float32 // in degrees per second.
32030                         Infotext         string
32031                         Itemstring       string
32032                         Glow             int8
32033                         MaxBreath        uint16  // Player only.
32034                         EyeHeight        float32 // Player only.
32035                         ZoomFOV          float32 // in degrees. Player only.
32036                         UseTextureAlpha  bool
32037                         DmgTextureMod    Texture // suffix
32038                         Shaded           bool
32039                         ShowOnMinimap    bool
32040                         NametagBG        color.NRGBA
32041                 }))(obj)).UseTextureAlpha
32042                 switch n := read8(r); n {
32043                 case 0:
32044                         *p = false
32045                 case 1:
32046                         *p = true
32047                 default:
32048                         chk(fmt.Errorf("invalid bool: %d", n))
32049                 }
32050         }
32051         if err := pcall(func() {
32052                 ((*(*(struct {
32053                         MaxHP            uint16 // Player only.
32054                         CollideWithNodes bool
32055                         Weight           float32 // deprecated
32056                         ColBox, SelBox   Box
32057                         Pointable        bool
32058                         Visual           string
32059                         VisualSize       [3]float32
32060                         Textures         []Texture
32061                         SpriteSheetSize  [2]int16 // in sprites.
32062                         SpritePos        [2]int16 // in sprite sheet.
32063                         Visible          bool
32064                         MakeFootstepSnds bool
32065                         RotateSpeed      float32 // in radians per second.
32066                         Mesh             string
32067                         Colors           []color.NRGBA
32068                         CollideWithAOs   bool
32069                         StepHeight       float32
32070                         FaceRotateDir    bool
32071                         FaceRotateDirOff float32 // in degrees.
32072                         BackfaceCull     bool
32073                         Nametag          string
32074                         NametagColor     color.NRGBA
32075                         FaceRotateSpeed  float32 // in degrees per second.
32076                         Infotext         string
32077                         Itemstring       string
32078                         Glow             int8
32079                         MaxBreath        uint16  // Player only.
32080                         EyeHeight        float32 // Player only.
32081                         ZoomFOV          float32 // in degrees. Player only.
32082                         UseTextureAlpha  bool
32083                         DmgTextureMod    Texture // suffix
32084                         Shaded           bool
32085                         ShowOnMinimap    bool
32086                         NametagBG        color.NRGBA
32087                 }))(obj)).DmgTextureMod).Deserialize(r)
32088         }); err != nil {
32089                 if err == io.EOF {
32090                         chk(io.EOF)
32091                 }
32092                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
32093         }
32094         {
32095                 p := &(*(*(struct {
32096                         MaxHP            uint16 // Player only.
32097                         CollideWithNodes bool
32098                         Weight           float32 // deprecated
32099                         ColBox, SelBox   Box
32100                         Pointable        bool
32101                         Visual           string
32102                         VisualSize       [3]float32
32103                         Textures         []Texture
32104                         SpriteSheetSize  [2]int16 // in sprites.
32105                         SpritePos        [2]int16 // in sprite sheet.
32106                         Visible          bool
32107                         MakeFootstepSnds bool
32108                         RotateSpeed      float32 // in radians per second.
32109                         Mesh             string
32110                         Colors           []color.NRGBA
32111                         CollideWithAOs   bool
32112                         StepHeight       float32
32113                         FaceRotateDir    bool
32114                         FaceRotateDirOff float32 // in degrees.
32115                         BackfaceCull     bool
32116                         Nametag          string
32117                         NametagColor     color.NRGBA
32118                         FaceRotateSpeed  float32 // in degrees per second.
32119                         Infotext         string
32120                         Itemstring       string
32121                         Glow             int8
32122                         MaxBreath        uint16  // Player only.
32123                         EyeHeight        float32 // Player only.
32124                         ZoomFOV          float32 // in degrees. Player only.
32125                         UseTextureAlpha  bool
32126                         DmgTextureMod    Texture // suffix
32127                         Shaded           bool
32128                         ShowOnMinimap    bool
32129                         NametagBG        color.NRGBA
32130                 }))(obj)).Shaded
32131                 switch n := read8(r); n {
32132                 case 0:
32133                         *p = false
32134                 case 1:
32135                         *p = true
32136                 default:
32137                         chk(fmt.Errorf("invalid bool: %d", n))
32138                 }
32139         }
32140         {
32141                 p := &(*(*(struct {
32142                         MaxHP            uint16 // Player only.
32143                         CollideWithNodes bool
32144                         Weight           float32 // deprecated
32145                         ColBox, SelBox   Box
32146                         Pointable        bool
32147                         Visual           string
32148                         VisualSize       [3]float32
32149                         Textures         []Texture
32150                         SpriteSheetSize  [2]int16 // in sprites.
32151                         SpritePos        [2]int16 // in sprite sheet.
32152                         Visible          bool
32153                         MakeFootstepSnds bool
32154                         RotateSpeed      float32 // in radians per second.
32155                         Mesh             string
32156                         Colors           []color.NRGBA
32157                         CollideWithAOs   bool
32158                         StepHeight       float32
32159                         FaceRotateDir    bool
32160                         FaceRotateDirOff float32 // in degrees.
32161                         BackfaceCull     bool
32162                         Nametag          string
32163                         NametagColor     color.NRGBA
32164                         FaceRotateSpeed  float32 // in degrees per second.
32165                         Infotext         string
32166                         Itemstring       string
32167                         Glow             int8
32168                         MaxBreath        uint16  // Player only.
32169                         EyeHeight        float32 // Player only.
32170                         ZoomFOV          float32 // in degrees. Player only.
32171                         UseTextureAlpha  bool
32172                         DmgTextureMod    Texture // suffix
32173                         Shaded           bool
32174                         ShowOnMinimap    bool
32175                         NametagBG        color.NRGBA
32176                 }))(obj)).ShowOnMinimap
32177                 switch n := read8(r); n {
32178                 case 0:
32179                         *p = false
32180                 case 1:
32181                         *p = true
32182                 default:
32183                         chk(fmt.Errorf("invalid bool: %d", n))
32184                 }
32185         }
32186         {
32187                 p := &(*(*(struct {
32188                         MaxHP            uint16 // Player only.
32189                         CollideWithNodes bool
32190                         Weight           float32 // deprecated
32191                         ColBox, SelBox   Box
32192                         Pointable        bool
32193                         Visual           string
32194                         VisualSize       [3]float32
32195                         Textures         []Texture
32196                         SpriteSheetSize  [2]int16 // in sprites.
32197                         SpritePos        [2]int16 // in sprite sheet.
32198                         Visible          bool
32199                         MakeFootstepSnds bool
32200                         RotateSpeed      float32 // in radians per second.
32201                         Mesh             string
32202                         Colors           []color.NRGBA
32203                         CollideWithAOs   bool
32204                         StepHeight       float32
32205                         FaceRotateDir    bool
32206                         FaceRotateDirOff float32 // in degrees.
32207                         BackfaceCull     bool
32208                         Nametag          string
32209                         NametagColor     color.NRGBA
32210                         FaceRotateSpeed  float32 // in degrees per second.
32211                         Infotext         string
32212                         Itemstring       string
32213                         Glow             int8
32214                         MaxBreath        uint16  // Player only.
32215                         EyeHeight        float32 // Player only.
32216                         ZoomFOV          float32 // in degrees. Player only.
32217                         UseTextureAlpha  bool
32218                         DmgTextureMod    Texture // suffix
32219                         Shaded           bool
32220                         ShowOnMinimap    bool
32221                         NametagBG        color.NRGBA
32222                 }))(obj)).NametagBG
32223                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
32224         }
32225 }
32226
32227 func (obj *AOPos) Serialize(w io.Writer) {
32228         if err := pcall(func() {
32229                 ((*(*(struct {
32230                         Pos
32231                         Vel, Acc Vec
32232                         Rot      [3]float32
32233
32234                         Interpolate    bool
32235                         End            bool
32236                         UpdateInterval float32
32237                 }))(obj)).Pos).Serialize(w)
32238         }); err != nil {
32239                 if err == io.EOF {
32240                         chk(io.EOF)
32241                 }
32242                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
32243         }
32244         if err := pcall(func() {
32245                 ((*(*(struct {
32246                         Pos
32247                         Vel, Acc Vec
32248                         Rot      [3]float32
32249
32250                         Interpolate    bool
32251                         End            bool
32252                         UpdateInterval float32
32253                 }))(obj)).Vel).Serialize(w)
32254         }); err != nil {
32255                 if err == io.EOF {
32256                         chk(io.EOF)
32257                 }
32258                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32259         }
32260         if err := pcall(func() {
32261                 ((*(*(struct {
32262                         Pos
32263                         Vel, Acc Vec
32264                         Rot      [3]float32
32265
32266                         Interpolate    bool
32267                         End            bool
32268                         UpdateInterval float32
32269                 }))(obj)).Acc).Serialize(w)
32270         }); err != nil {
32271                 if err == io.EOF {
32272                         chk(io.EOF)
32273                 }
32274                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32275         }
32276         for local355 := range (*(*(struct {
32277                 Pos
32278                 Vel, Acc Vec
32279                 Rot      [3]float32
32280
32281                 Interpolate    bool
32282                 End            bool
32283                 UpdateInterval float32
32284         }))(obj)).Rot {
32285                 {
32286                         x := ((*(*(struct {
32287                                 Pos
32288                                 Vel, Acc Vec
32289                                 Rot      [3]float32
32290
32291                                 Interpolate    bool
32292                                 End            bool
32293                                 UpdateInterval float32
32294                         }))(obj)).Rot)[local355]
32295                         write32(w, math.Float32bits(x))
32296                 }
32297         }
32298         {
32299                 x := (*(*(struct {
32300                         Pos
32301                         Vel, Acc Vec
32302                         Rot      [3]float32
32303
32304                         Interpolate    bool
32305                         End            bool
32306                         UpdateInterval float32
32307                 }))(obj)).Interpolate
32308                 if x {
32309                         write8(w, 1)
32310                 } else {
32311                         write8(w, 0)
32312                 }
32313         }
32314         {
32315                 x := (*(*(struct {
32316                         Pos
32317                         Vel, Acc Vec
32318                         Rot      [3]float32
32319
32320                         Interpolate    bool
32321                         End            bool
32322                         UpdateInterval float32
32323                 }))(obj)).End
32324                 if x {
32325                         write8(w, 1)
32326                 } else {
32327                         write8(w, 0)
32328                 }
32329         }
32330         {
32331                 x := (*(*(struct {
32332                         Pos
32333                         Vel, Acc Vec
32334                         Rot      [3]float32
32335
32336                         Interpolate    bool
32337                         End            bool
32338                         UpdateInterval float32
32339                 }))(obj)).UpdateInterval
32340                 write32(w, math.Float32bits(x))
32341         }
32342 }
32343
32344 func (obj *AOPos) Deserialize(r io.Reader) {
32345         if err := pcall(func() {
32346                 ((*(*(struct {
32347                         Pos
32348                         Vel, Acc Vec
32349                         Rot      [3]float32
32350
32351                         Interpolate    bool
32352                         End            bool
32353                         UpdateInterval float32
32354                 }))(obj)).Pos).Deserialize(r)
32355         }); err != nil {
32356                 if err == io.EOF {
32357                         chk(io.EOF)
32358                 }
32359                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
32360         }
32361         if err := pcall(func() {
32362                 ((*(*(struct {
32363                         Pos
32364                         Vel, Acc Vec
32365                         Rot      [3]float32
32366
32367                         Interpolate    bool
32368                         End            bool
32369                         UpdateInterval float32
32370                 }))(obj)).Vel).Deserialize(r)
32371         }); err != nil {
32372                 if err == io.EOF {
32373                         chk(io.EOF)
32374                 }
32375                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32376         }
32377         if err := pcall(func() {
32378                 ((*(*(struct {
32379                         Pos
32380                         Vel, Acc Vec
32381                         Rot      [3]float32
32382
32383                         Interpolate    bool
32384                         End            bool
32385                         UpdateInterval float32
32386                 }))(obj)).Acc).Deserialize(r)
32387         }); err != nil {
32388                 if err == io.EOF {
32389                         chk(io.EOF)
32390                 }
32391                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32392         }
32393         for local356 := range (*(*(struct {
32394                 Pos
32395                 Vel, Acc Vec
32396                 Rot      [3]float32
32397
32398                 Interpolate    bool
32399                 End            bool
32400                 UpdateInterval float32
32401         }))(obj)).Rot {
32402                 {
32403                         p := &((*(*(struct {
32404                                 Pos
32405                                 Vel, Acc Vec
32406                                 Rot      [3]float32
32407
32408                                 Interpolate    bool
32409                                 End            bool
32410                                 UpdateInterval float32
32411                         }))(obj)).Rot)[local356]
32412                         *p = math.Float32frombits(read32(r))
32413                 }
32414         }
32415         {
32416                 p := &(*(*(struct {
32417                         Pos
32418                         Vel, Acc Vec
32419                         Rot      [3]float32
32420
32421                         Interpolate    bool
32422                         End            bool
32423                         UpdateInterval float32
32424                 }))(obj)).Interpolate
32425                 switch n := read8(r); n {
32426                 case 0:
32427                         *p = false
32428                 case 1:
32429                         *p = true
32430                 default:
32431                         chk(fmt.Errorf("invalid bool: %d", n))
32432                 }
32433         }
32434         {
32435                 p := &(*(*(struct {
32436                         Pos
32437                         Vel, Acc Vec
32438                         Rot      [3]float32
32439
32440                         Interpolate    bool
32441                         End            bool
32442                         UpdateInterval float32
32443                 }))(obj)).End
32444                 switch n := read8(r); n {
32445                 case 0:
32446                         *p = false
32447                 case 1:
32448                         *p = true
32449                 default:
32450                         chk(fmt.Errorf("invalid bool: %d", n))
32451                 }
32452         }
32453         {
32454                 p := &(*(*(struct {
32455                         Pos
32456                         Vel, Acc Vec
32457                         Rot      [3]float32
32458
32459                         Interpolate    bool
32460                         End            bool
32461                         UpdateInterval float32
32462                 }))(obj)).UpdateInterval
32463                 *p = math.Float32frombits(read32(r))
32464         }
32465 }
32466
32467 func (obj *AOSprite) Serialize(w io.Writer) {
32468         for local357 := range (*(*(struct {
32469                 Frame0          [2]int16
32470                 Frames          uint16
32471                 FrameDuration   float32
32472                 ViewAngleFrames bool
32473         }))(obj)).Frame0 {
32474                 {
32475                         x := ((*(*(struct {
32476                                 Frame0          [2]int16
32477                                 Frames          uint16
32478                                 FrameDuration   float32
32479                                 ViewAngleFrames bool
32480                         }))(obj)).Frame0)[local357]
32481                         write16(w, uint16(x))
32482                 }
32483         }
32484         {
32485                 x := (*(*(struct {
32486                         Frame0          [2]int16
32487                         Frames          uint16
32488                         FrameDuration   float32
32489                         ViewAngleFrames bool
32490                 }))(obj)).Frames
32491                 write16(w, uint16(x))
32492         }
32493         {
32494                 x := (*(*(struct {
32495                         Frame0          [2]int16
32496                         Frames          uint16
32497                         FrameDuration   float32
32498                         ViewAngleFrames bool
32499                 }))(obj)).FrameDuration
32500                 write32(w, math.Float32bits(x))
32501         }
32502         {
32503                 x := (*(*(struct {
32504                         Frame0          [2]int16
32505                         Frames          uint16
32506                         FrameDuration   float32
32507                         ViewAngleFrames bool
32508                 }))(obj)).ViewAngleFrames
32509                 if x {
32510                         write8(w, 1)
32511                 } else {
32512                         write8(w, 0)
32513                 }
32514         }
32515 }
32516
32517 func (obj *AOSprite) Deserialize(r io.Reader) {
32518         for local358 := range (*(*(struct {
32519                 Frame0          [2]int16
32520                 Frames          uint16
32521                 FrameDuration   float32
32522                 ViewAngleFrames bool
32523         }))(obj)).Frame0 {
32524                 {
32525                         p := &((*(*(struct {
32526                                 Frame0          [2]int16
32527                                 Frames          uint16
32528                                 FrameDuration   float32
32529                                 ViewAngleFrames bool
32530                         }))(obj)).Frame0)[local358]
32531                         *p = int16(read16(r))
32532                 }
32533         }
32534         {
32535                 p := &(*(*(struct {
32536                         Frame0          [2]int16
32537                         Frames          uint16
32538                         FrameDuration   float32
32539                         ViewAngleFrames bool
32540                 }))(obj)).Frames
32541                 *p = read16(r)
32542         }
32543         {
32544                 p := &(*(*(struct {
32545                         Frame0          [2]int16
32546                         Frames          uint16
32547                         FrameDuration   float32
32548                         ViewAngleFrames bool
32549                 }))(obj)).FrameDuration
32550                 *p = math.Float32frombits(read32(r))
32551         }
32552         {
32553                 p := &(*(*(struct {
32554                         Frame0          [2]int16
32555                         Frames          uint16
32556                         FrameDuration   float32
32557                         ViewAngleFrames bool
32558                 }))(obj)).ViewAngleFrames
32559                 switch n := read8(r); n {
32560                 case 0:
32561                         *p = false
32562                 case 1:
32563                         *p = true
32564                 default:
32565                         chk(fmt.Errorf("invalid bool: %d", n))
32566                 }
32567         }
32568 }
32569
32570 func (obj *Group) Serialize(w io.Writer) {
32571         if len(([]byte((*(*(struct {
32572                 Name   string
32573                 Rating int16
32574         }))(obj)).Name))) > math.MaxUint16 {
32575                 chk(ErrTooLong)
32576         }
32577         {
32578                 x := uint16(len(([]byte((*(*(struct {
32579                         Name   string
32580                         Rating int16
32581                 }))(obj)).Name))))
32582                 write16(w, uint16(x))
32583         }
32584         {
32585                 _, err := w.Write(([]byte((*(*(struct {
32586                         Name   string
32587                         Rating int16
32588                 }))(obj)).Name))[:])
32589                 chk(err)
32590         }
32591         {
32592                 x := (*(*(struct {
32593                         Name   string
32594                         Rating int16
32595                 }))(obj)).Rating
32596                 write16(w, uint16(x))
32597         }
32598 }
32599
32600 func (obj *Group) Deserialize(r io.Reader) {
32601         var local359 []uint8
32602         var local360 uint16
32603         {
32604                 p := &local360
32605                 *p = read16(r)
32606         }
32607         (local359) = make([]uint8, local360)
32608         {
32609                 _, err := io.ReadFull(r, (local359)[:])
32610                 chk(err)
32611         }
32612         ((*(*(struct {
32613                 Name   string
32614                 Rating int16
32615         }))(obj)).Name) = string(local359)
32616         {
32617                 p := &(*(*(struct {
32618                         Name   string
32619                         Rating int16
32620                 }))(obj)).Rating
32621                 *p = int16(read16(r))
32622         }
32623 }
32624
32625 func (obj *AOAnim) Serialize(w io.Writer) {
32626         for local361 := range (*(*(struct {
32627                 Frames [2]int32
32628                 Speed  float32
32629                 Blend  float32
32630                 NoLoop bool
32631         }))(obj)).Frames {
32632                 {
32633                         x := ((*(*(struct {
32634                                 Frames [2]int32
32635                                 Speed  float32
32636                                 Blend  float32
32637                                 NoLoop bool
32638                         }))(obj)).Frames)[local361]
32639                         write32(w, uint32(x))
32640                 }
32641         }
32642         {
32643                 x := (*(*(struct {
32644                         Frames [2]int32
32645                         Speed  float32
32646                         Blend  float32
32647                         NoLoop bool
32648                 }))(obj)).Speed
32649                 write32(w, math.Float32bits(x))
32650         }
32651         {
32652                 x := (*(*(struct {
32653                         Frames [2]int32
32654                         Speed  float32
32655                         Blend  float32
32656                         NoLoop bool
32657                 }))(obj)).Blend
32658                 write32(w, math.Float32bits(x))
32659         }
32660         {
32661                 x := (*(*(struct {
32662                         Frames [2]int32
32663                         Speed  float32
32664                         Blend  float32
32665                         NoLoop bool
32666                 }))(obj)).NoLoop
32667                 if x {
32668                         write8(w, 1)
32669                 } else {
32670                         write8(w, 0)
32671                 }
32672         }
32673 }
32674
32675 func (obj *AOAnim) Deserialize(r io.Reader) {
32676         for local362 := range (*(*(struct {
32677                 Frames [2]int32
32678                 Speed  float32
32679                 Blend  float32
32680                 NoLoop bool
32681         }))(obj)).Frames {
32682                 {
32683                         p := &((*(*(struct {
32684                                 Frames [2]int32
32685                                 Speed  float32
32686                                 Blend  float32
32687                                 NoLoop bool
32688                         }))(obj)).Frames)[local362]
32689                         *p = int32(read32(r))
32690                 }
32691         }
32692         {
32693                 p := &(*(*(struct {
32694                         Frames [2]int32
32695                         Speed  float32
32696                         Blend  float32
32697                         NoLoop bool
32698                 }))(obj)).Speed
32699                 *p = math.Float32frombits(read32(r))
32700         }
32701         {
32702                 p := &(*(*(struct {
32703                         Frames [2]int32
32704                         Speed  float32
32705                         Blend  float32
32706                         NoLoop bool
32707                 }))(obj)).Blend
32708                 *p = math.Float32frombits(read32(r))
32709         }
32710         {
32711                 p := &(*(*(struct {
32712                         Frames [2]int32
32713                         Speed  float32
32714                         Blend  float32
32715                         NoLoop bool
32716                 }))(obj)).NoLoop
32717                 switch n := read8(r); n {
32718                 case 0:
32719                         *p = false
32720                 case 1:
32721                         *p = true
32722                 default:
32723                         chk(fmt.Errorf("invalid bool: %d", n))
32724                 }
32725         }
32726 }
32727
32728 func (obj *AOBonePos) Serialize(w io.Writer) {
32729         if err := pcall(func() {
32730                 ((*(*(struct {
32731                         Pos Vec
32732                         Rot [3]float32
32733                 }))(obj)).Pos).Serialize(w)
32734         }); err != nil {
32735                 if err == io.EOF {
32736                         chk(io.EOF)
32737                 }
32738                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32739         }
32740         for local363 := range (*(*(struct {
32741                 Pos Vec
32742                 Rot [3]float32
32743         }))(obj)).Rot {
32744                 {
32745                         x := ((*(*(struct {
32746                                 Pos Vec
32747                                 Rot [3]float32
32748                         }))(obj)).Rot)[local363]
32749                         write32(w, math.Float32bits(x))
32750                 }
32751         }
32752 }
32753
32754 func (obj *AOBonePos) Deserialize(r io.Reader) {
32755         if err := pcall(func() {
32756                 ((*(*(struct {
32757                         Pos Vec
32758                         Rot [3]float32
32759                 }))(obj)).Pos).Deserialize(r)
32760         }); err != nil {
32761                 if err == io.EOF {
32762                         chk(io.EOF)
32763                 }
32764                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32765         }
32766         for local364 := range (*(*(struct {
32767                 Pos Vec
32768                 Rot [3]float32
32769         }))(obj)).Rot {
32770                 {
32771                         p := &((*(*(struct {
32772                                 Pos Vec
32773                                 Rot [3]float32
32774                         }))(obj)).Rot)[local364]
32775                         *p = math.Float32frombits(read32(r))
32776                 }
32777         }
32778 }
32779
32780 func (obj *AOAttach) Serialize(w io.Writer) {
32781         if err := pcall(func() {
32782                 ((*(*(struct {
32783                         ParentID     AOID
32784                         Bone         string
32785                         Pos          Vec
32786                         Rot          [3]float32
32787                         ForceVisible bool
32788                 }))(obj)).ParentID).Serialize(w)
32789         }); err != nil {
32790                 if err == io.EOF {
32791                         chk(io.EOF)
32792                 }
32793                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
32794         }
32795         if len(([]byte((*(*(struct {
32796                 ParentID     AOID
32797                 Bone         string
32798                 Pos          Vec
32799                 Rot          [3]float32
32800                 ForceVisible bool
32801         }))(obj)).Bone))) > math.MaxUint16 {
32802                 chk(ErrTooLong)
32803         }
32804         {
32805                 x := uint16(len(([]byte((*(*(struct {
32806                         ParentID     AOID
32807                         Bone         string
32808                         Pos          Vec
32809                         Rot          [3]float32
32810                         ForceVisible bool
32811                 }))(obj)).Bone))))
32812                 write16(w, uint16(x))
32813         }
32814         {
32815                 _, err := w.Write(([]byte((*(*(struct {
32816                         ParentID     AOID
32817                         Bone         string
32818                         Pos          Vec
32819                         Rot          [3]float32
32820                         ForceVisible bool
32821                 }))(obj)).Bone))[:])
32822                 chk(err)
32823         }
32824         if err := pcall(func() {
32825                 ((*(*(struct {
32826                         ParentID     AOID
32827                         Bone         string
32828                         Pos          Vec
32829                         Rot          [3]float32
32830                         ForceVisible bool
32831                 }))(obj)).Pos).Serialize(w)
32832         }); err != nil {
32833                 if err == io.EOF {
32834                         chk(io.EOF)
32835                 }
32836                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32837         }
32838         for local365 := range (*(*(struct {
32839                 ParentID     AOID
32840                 Bone         string
32841                 Pos          Vec
32842                 Rot          [3]float32
32843                 ForceVisible bool
32844         }))(obj)).Rot {
32845                 {
32846                         x := ((*(*(struct {
32847                                 ParentID     AOID
32848                                 Bone         string
32849                                 Pos          Vec
32850                                 Rot          [3]float32
32851                                 ForceVisible bool
32852                         }))(obj)).Rot)[local365]
32853                         write32(w, math.Float32bits(x))
32854                 }
32855         }
32856         {
32857                 x := (*(*(struct {
32858                         ParentID     AOID
32859                         Bone         string
32860                         Pos          Vec
32861                         Rot          [3]float32
32862                         ForceVisible bool
32863                 }))(obj)).ForceVisible
32864                 if x {
32865                         write8(w, 1)
32866                 } else {
32867                         write8(w, 0)
32868                 }
32869         }
32870 }
32871
32872 func (obj *AOAttach) Deserialize(r io.Reader) {
32873         if err := pcall(func() {
32874                 ((*(*(struct {
32875                         ParentID     AOID
32876                         Bone         string
32877                         Pos          Vec
32878                         Rot          [3]float32
32879                         ForceVisible bool
32880                 }))(obj)).ParentID).Deserialize(r)
32881         }); err != nil {
32882                 if err == io.EOF {
32883                         chk(io.EOF)
32884                 }
32885                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
32886         }
32887         var local366 []uint8
32888         var local367 uint16
32889         {
32890                 p := &local367
32891                 *p = read16(r)
32892         }
32893         (local366) = make([]uint8, local367)
32894         {
32895                 _, err := io.ReadFull(r, (local366)[:])
32896                 chk(err)
32897         }
32898         ((*(*(struct {
32899                 ParentID     AOID
32900                 Bone         string
32901                 Pos          Vec
32902                 Rot          [3]float32
32903                 ForceVisible bool
32904         }))(obj)).Bone) = string(local366)
32905         if err := pcall(func() {
32906                 ((*(*(struct {
32907                         ParentID     AOID
32908                         Bone         string
32909                         Pos          Vec
32910                         Rot          [3]float32
32911                         ForceVisible bool
32912                 }))(obj)).Pos).Deserialize(r)
32913         }); err != nil {
32914                 if err == io.EOF {
32915                         chk(io.EOF)
32916                 }
32917                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32918         }
32919         for local368 := range (*(*(struct {
32920                 ParentID     AOID
32921                 Bone         string
32922                 Pos          Vec
32923                 Rot          [3]float32
32924                 ForceVisible bool
32925         }))(obj)).Rot {
32926                 {
32927                         p := &((*(*(struct {
32928                                 ParentID     AOID
32929                                 Bone         string
32930                                 Pos          Vec
32931                                 Rot          [3]float32
32932                                 ForceVisible bool
32933                         }))(obj)).Rot)[local368]
32934                         *p = math.Float32frombits(read32(r))
32935                 }
32936         }
32937         {
32938                 p := &(*(*(struct {
32939                         ParentID     AOID
32940                         Bone         string
32941                         Pos          Vec
32942                         Rot          [3]float32
32943                         ForceVisible bool
32944                 }))(obj)).ForceVisible
32945                 switch n := read8(r); n {
32946                 case 0:
32947                         *p = false
32948                 case 1:
32949                         *p = true
32950                 default:
32951                         chk(fmt.Errorf("invalid bool: %d", n))
32952                 }
32953         }
32954 }
32955
32956 func (obj *AOPhysOverride) Serialize(w io.Writer) {
32957         {
32958                 x := (*(*(struct {
32959                         Walk, Jump, Gravity float32
32960
32961                         // Player only.
32962                         NoSneak, NoSneakGlitch, OldSneak bool
32963                 }))(obj)).Walk
32964                 write32(w, math.Float32bits(x))
32965         }
32966         {
32967                 x := (*(*(struct {
32968                         Walk, Jump, Gravity float32
32969
32970                         // Player only.
32971                         NoSneak, NoSneakGlitch, OldSneak bool
32972                 }))(obj)).Jump
32973                 write32(w, math.Float32bits(x))
32974         }
32975         {
32976                 x := (*(*(struct {
32977                         Walk, Jump, Gravity float32
32978
32979                         // Player only.
32980                         NoSneak, NoSneakGlitch, OldSneak bool
32981                 }))(obj)).Gravity
32982                 write32(w, math.Float32bits(x))
32983         }
32984         {
32985                 x := (*(*(struct {
32986                         Walk, Jump, Gravity float32
32987
32988                         // Player only.
32989                         NoSneak, NoSneakGlitch, OldSneak bool
32990                 }))(obj)).NoSneak
32991                 if x {
32992                         write8(w, 1)
32993                 } else {
32994                         write8(w, 0)
32995                 }
32996         }
32997         {
32998                 x := (*(*(struct {
32999                         Walk, Jump, Gravity float32
33000
33001                         // Player only.
33002                         NoSneak, NoSneakGlitch, OldSneak bool
33003                 }))(obj)).NoSneakGlitch
33004                 if x {
33005                         write8(w, 1)
33006                 } else {
33007                         write8(w, 0)
33008                 }
33009         }
33010         {
33011                 x := (*(*(struct {
33012                         Walk, Jump, Gravity float32
33013
33014                         // Player only.
33015                         NoSneak, NoSneakGlitch, OldSneak bool
33016                 }))(obj)).OldSneak
33017                 if x {
33018                         write8(w, 1)
33019                 } else {
33020                         write8(w, 0)
33021                 }
33022         }
33023 }
33024
33025 func (obj *AOPhysOverride) Deserialize(r io.Reader) {
33026         {
33027                 p := &(*(*(struct {
33028                         Walk, Jump, Gravity float32
33029
33030                         // Player only.
33031                         NoSneak, NoSneakGlitch, OldSneak bool
33032                 }))(obj)).Walk
33033                 *p = math.Float32frombits(read32(r))
33034         }
33035         {
33036                 p := &(*(*(struct {
33037                         Walk, Jump, Gravity float32
33038
33039                         // Player only.
33040                         NoSneak, NoSneakGlitch, OldSneak bool
33041                 }))(obj)).Jump
33042                 *p = math.Float32frombits(read32(r))
33043         }
33044         {
33045                 p := &(*(*(struct {
33046                         Walk, Jump, Gravity float32
33047
33048                         // Player only.
33049                         NoSneak, NoSneakGlitch, OldSneak bool
33050                 }))(obj)).Gravity
33051                 *p = math.Float32frombits(read32(r))
33052         }
33053         {
33054                 p := &(*(*(struct {
33055                         Walk, Jump, Gravity float32
33056
33057                         // Player only.
33058                         NoSneak, NoSneakGlitch, OldSneak bool
33059                 }))(obj)).NoSneak
33060                 switch n := read8(r); n {
33061                 case 0:
33062                         *p = false
33063                 case 1:
33064                         *p = true
33065                 default:
33066                         chk(fmt.Errorf("invalid bool: %d", n))
33067                 }
33068         }
33069         {
33070                 p := &(*(*(struct {
33071                         Walk, Jump, Gravity float32
33072
33073                         // Player only.
33074                         NoSneak, NoSneakGlitch, OldSneak bool
33075                 }))(obj)).NoSneakGlitch
33076                 switch n := read8(r); n {
33077                 case 0:
33078                         *p = false
33079                 case 1:
33080                         *p = true
33081                 default:
33082                         chk(fmt.Errorf("invalid bool: %d", n))
33083                 }
33084         }
33085         {
33086                 p := &(*(*(struct {
33087                         Walk, Jump, Gravity float32
33088
33089                         // Player only.
33090                         NoSneak, NoSneakGlitch, OldSneak bool
33091                 }))(obj)).OldSneak
33092                 switch n := read8(r); n {
33093                 case 0:
33094                         *p = false
33095                 case 1:
33096                         *p = true
33097                 default:
33098                         chk(fmt.Errorf("invalid bool: %d", n))
33099                 }
33100         }
33101 }
33102
33103 func (obj *aoType) Serialize(w io.Writer) {
33104         {
33105                 x := *(*(uint8))(obj)
33106                 write8(w, uint8(x))
33107         }
33108 }
33109
33110 func (obj *aoType) Deserialize(r io.Reader) {
33111         {
33112                 p := &*(*(uint8))(obj)
33113                 *p = read8(r)
33114         }
33115 }
33116
33117 func (obj *NodeMetaField) Serialize(w io.Writer) {
33118         if err := pcall(func() {
33119                 ((*(*(struct {
33120                         Field
33121                         Private bool
33122                 }))(obj)).Field).Serialize(w)
33123         }); err != nil {
33124                 if err == io.EOF {
33125                         chk(io.EOF)
33126                 }
33127                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
33128         }
33129         {
33130                 x := (*(*(struct {
33131                         Field
33132                         Private bool
33133                 }))(obj)).Private
33134                 if x {
33135                         write8(w, 1)
33136                 } else {
33137                         write8(w, 0)
33138                 }
33139         }
33140 }
33141
33142 func (obj *NodeMetaField) Deserialize(r io.Reader) {
33143         if err := pcall(func() {
33144                 ((*(*(struct {
33145                         Field
33146                         Private bool
33147                 }))(obj)).Field).Deserialize(r)
33148         }); err != nil {
33149                 if err == io.EOF {
33150                         chk(io.EOF)
33151                 }
33152                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
33153         }
33154         {
33155                 p := &(*(*(struct {
33156                         Field
33157                         Private bool
33158                 }))(obj)).Private
33159                 switch n := read8(r); n {
33160                 case 0:
33161                         *p = false
33162                 case 1:
33163                         *p = true
33164                 default:
33165                         chk(fmt.Errorf("invalid bool: %d", n))
33166                 }
33167         }
33168 }
33169
33170 func (obj *MinimapType) Serialize(w io.Writer) {
33171         {
33172                 x := *(*(uint16))(obj)
33173                 write16(w, uint16(x))
33174         }
33175 }
33176
33177 func (obj *MinimapType) Deserialize(r io.Reader) {
33178         {
33179                 p := &*(*(uint16))(obj)
33180                 *p = read16(r)
33181         }
33182 }
33183
33184 func (obj *Param1Type) Serialize(w io.Writer) {
33185         {
33186                 x := *(*(uint8))(obj)
33187                 write8(w, uint8(x))
33188         }
33189 }
33190
33191 func (obj *Param1Type) Deserialize(r io.Reader) {
33192         {
33193                 p := &*(*(uint8))(obj)
33194                 *p = read8(r)
33195         }
33196 }
33197
33198 func (obj *Param2Type) Serialize(w io.Writer) {
33199         {
33200                 x := *(*(uint8))(obj)
33201                 write8(w, uint8(x))
33202         }
33203 }
33204
33205 func (obj *Param2Type) Deserialize(r io.Reader) {
33206         {
33207                 p := &*(*(uint8))(obj)
33208                 *p = read8(r)
33209         }
33210 }
33211
33212 func (obj *DrawType) Serialize(w io.Writer) {
33213         {
33214                 x := *(*(uint8))(obj)
33215                 write8(w, uint8(x))
33216         }
33217 }
33218
33219 func (obj *DrawType) Deserialize(r io.Reader) {
33220         {
33221                 p := &*(*(uint8))(obj)
33222                 *p = read8(r)
33223         }
33224 }
33225
33226 func (obj *TileDef) Serialize(w io.Writer) {
33227         {
33228                 local369 := uint8(6)
33229                 {
33230                         x := local369
33231                         write8(w, uint8(x))
33232                 }
33233         }
33234         if err := pcall(func() {
33235                 ((*(*(struct {
33236                         Texture
33237                         Anim  TileAnim
33238                         Flags TileFlags
33239
33240                         //mt:if %s.Flags&TileColor != 0
33241                         R, G, B uint8
33242
33243                         //mt:if %s.Flags&TileScale != 0
33244                         Scale uint8
33245
33246                         //mt:if %s.Flags&TileAlign != 0
33247                         Align AlignType
33248                 }))(obj)).Texture).Serialize(w)
33249         }); err != nil {
33250                 if err == io.EOF {
33251                         chk(io.EOF)
33252                 }
33253                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
33254         }
33255         if err := pcall(func() {
33256                 ((*(*(struct {
33257                         Texture
33258                         Anim  TileAnim
33259                         Flags TileFlags
33260
33261                         //mt:if %s.Flags&TileColor != 0
33262                         R, G, B uint8
33263
33264                         //mt:if %s.Flags&TileScale != 0
33265                         Scale uint8
33266
33267                         //mt:if %s.Flags&TileAlign != 0
33268                         Align AlignType
33269                 }))(obj)).Anim).Serialize(w)
33270         }); err != nil {
33271                 if err == io.EOF {
33272                         chk(io.EOF)
33273                 }
33274                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
33275         }
33276         if err := pcall(func() {
33277                 ((*(*(struct {
33278                         Texture
33279                         Anim  TileAnim
33280                         Flags TileFlags
33281
33282                         //mt:if %s.Flags&TileColor != 0
33283                         R, G, B uint8
33284
33285                         //mt:if %s.Flags&TileScale != 0
33286                         Scale uint8
33287
33288                         //mt:if %s.Flags&TileAlign != 0
33289                         Align AlignType
33290                 }))(obj)).Flags).Serialize(w)
33291         }); err != nil {
33292                 if err == io.EOF {
33293                         chk(io.EOF)
33294                 }
33295                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
33296         }
33297         if (*(*(struct {
33298                 Texture
33299                 Anim  TileAnim
33300                 Flags TileFlags
33301
33302                 //mt:if %s.Flags&TileColor != 0
33303                 R, G, B uint8
33304
33305                 //mt:if %s.Flags&TileScale != 0
33306                 Scale uint8
33307
33308                 //mt:if %s.Flags&TileAlign != 0
33309                 Align AlignType
33310         }))(obj)).Flags&TileColor != 0 {
33311                 {
33312                         x := (*(*(struct {
33313                                 Texture
33314                                 Anim  TileAnim
33315                                 Flags TileFlags
33316
33317                                 //mt:if %s.Flags&TileColor != 0
33318                                 R, G, B uint8
33319
33320                                 //mt:if %s.Flags&TileScale != 0
33321                                 Scale uint8
33322
33323                                 //mt:if %s.Flags&TileAlign != 0
33324                                 Align AlignType
33325                         }))(obj)).R
33326                         write8(w, uint8(x))
33327                 }
33328                 {
33329                         x := (*(*(struct {
33330                                 Texture
33331                                 Anim  TileAnim
33332                                 Flags TileFlags
33333
33334                                 //mt:if %s.Flags&TileColor != 0
33335                                 R, G, B uint8
33336
33337                                 //mt:if %s.Flags&TileScale != 0
33338                                 Scale uint8
33339
33340                                 //mt:if %s.Flags&TileAlign != 0
33341                                 Align AlignType
33342                         }))(obj)).G
33343                         write8(w, uint8(x))
33344                 }
33345                 {
33346                         x := (*(*(struct {
33347                                 Texture
33348                                 Anim  TileAnim
33349                                 Flags TileFlags
33350
33351                                 //mt:if %s.Flags&TileColor != 0
33352                                 R, G, B uint8
33353
33354                                 //mt:if %s.Flags&TileScale != 0
33355                                 Scale uint8
33356
33357                                 //mt:if %s.Flags&TileAlign != 0
33358                                 Align AlignType
33359                         }))(obj)).B
33360                         write8(w, uint8(x))
33361                 }
33362         }
33363         if (*(*(struct {
33364                 Texture
33365                 Anim  TileAnim
33366                 Flags TileFlags
33367
33368                 //mt:if %s.Flags&TileColor != 0
33369                 R, G, B uint8
33370
33371                 //mt:if %s.Flags&TileScale != 0
33372                 Scale uint8
33373
33374                 //mt:if %s.Flags&TileAlign != 0
33375                 Align AlignType
33376         }))(obj)).Flags&TileScale != 0 {
33377                 {
33378                         x := (*(*(struct {
33379                                 Texture
33380                                 Anim  TileAnim
33381                                 Flags TileFlags
33382
33383                                 //mt:if %s.Flags&TileColor != 0
33384                                 R, G, B uint8
33385
33386                                 //mt:if %s.Flags&TileScale != 0
33387                                 Scale uint8
33388
33389                                 //mt:if %s.Flags&TileAlign != 0
33390                                 Align AlignType
33391                         }))(obj)).Scale
33392                         write8(w, uint8(x))
33393                 }
33394         }
33395         if (*(*(struct {
33396                 Texture
33397                 Anim  TileAnim
33398                 Flags TileFlags
33399
33400                 //mt:if %s.Flags&TileColor != 0
33401                 R, G, B uint8
33402
33403                 //mt:if %s.Flags&TileScale != 0
33404                 Scale uint8
33405
33406                 //mt:if %s.Flags&TileAlign != 0
33407                 Align AlignType
33408         }))(obj)).Flags&TileAlign != 0 {
33409                 if err := pcall(func() {
33410                         ((*(*(struct {
33411                                 Texture
33412                                 Anim  TileAnim
33413                                 Flags TileFlags
33414
33415                                 //mt:if %s.Flags&TileColor != 0
33416                                 R, G, B uint8
33417
33418                                 //mt:if %s.Flags&TileScale != 0
33419                                 Scale uint8
33420
33421                                 //mt:if %s.Flags&TileAlign != 0
33422                                 Align AlignType
33423                         }))(obj)).Align).Serialize(w)
33424                 }); err != nil {
33425                         if err == io.EOF {
33426                                 chk(io.EOF)
33427                         }
33428                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
33429                 }
33430         }
33431 }
33432
33433 func (obj *TileDef) Deserialize(r io.Reader) {
33434         {
33435                 var local370 uint8
33436                 local371 := uint8(6)
33437                 {
33438                         p := &local370
33439                         *p = read8(r)
33440                 }
33441                 if local370 != local371 {
33442                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local370))
33443                 }
33444         }
33445         if err := pcall(func() {
33446                 ((*(*(struct {
33447                         Texture
33448                         Anim  TileAnim
33449                         Flags TileFlags
33450
33451                         //mt:if %s.Flags&TileColor != 0
33452                         R, G, B uint8
33453
33454                         //mt:if %s.Flags&TileScale != 0
33455                         Scale uint8
33456
33457                         //mt:if %s.Flags&TileAlign != 0
33458                         Align AlignType
33459                 }))(obj)).Texture).Deserialize(r)
33460         }); err != nil {
33461                 if err == io.EOF {
33462                         chk(io.EOF)
33463                 }
33464                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
33465         }
33466         if err := pcall(func() {
33467                 ((*(*(struct {
33468                         Texture
33469                         Anim  TileAnim
33470                         Flags TileFlags
33471
33472                         //mt:if %s.Flags&TileColor != 0
33473                         R, G, B uint8
33474
33475                         //mt:if %s.Flags&TileScale != 0
33476                         Scale uint8
33477
33478                         //mt:if %s.Flags&TileAlign != 0
33479                         Align AlignType
33480                 }))(obj)).Anim).Deserialize(r)
33481         }); err != nil {
33482                 if err == io.EOF {
33483                         chk(io.EOF)
33484                 }
33485                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
33486         }
33487         if err := pcall(func() {
33488                 ((*(*(struct {
33489                         Texture
33490                         Anim  TileAnim
33491                         Flags TileFlags
33492
33493                         //mt:if %s.Flags&TileColor != 0
33494                         R, G, B uint8
33495
33496                         //mt:if %s.Flags&TileScale != 0
33497                         Scale uint8
33498
33499                         //mt:if %s.Flags&TileAlign != 0
33500                         Align AlignType
33501                 }))(obj)).Flags).Deserialize(r)
33502         }); err != nil {
33503                 if err == io.EOF {
33504                         chk(io.EOF)
33505                 }
33506                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
33507         }
33508         if (*(*(struct {
33509                 Texture
33510                 Anim  TileAnim
33511                 Flags TileFlags
33512
33513                 //mt:if %s.Flags&TileColor != 0
33514                 R, G, B uint8
33515
33516                 //mt:if %s.Flags&TileScale != 0
33517                 Scale uint8
33518
33519                 //mt:if %s.Flags&TileAlign != 0
33520                 Align AlignType
33521         }))(obj)).Flags&TileColor != 0 {
33522                 {
33523                         p := &(*(*(struct {
33524                                 Texture
33525                                 Anim  TileAnim
33526                                 Flags TileFlags
33527
33528                                 //mt:if %s.Flags&TileColor != 0
33529                                 R, G, B uint8
33530
33531                                 //mt:if %s.Flags&TileScale != 0
33532                                 Scale uint8
33533
33534                                 //mt:if %s.Flags&TileAlign != 0
33535                                 Align AlignType
33536                         }))(obj)).R
33537                         *p = read8(r)
33538                 }
33539                 {
33540                         p := &(*(*(struct {
33541                                 Texture
33542                                 Anim  TileAnim
33543                                 Flags TileFlags
33544
33545                                 //mt:if %s.Flags&TileColor != 0
33546                                 R, G, B uint8
33547
33548                                 //mt:if %s.Flags&TileScale != 0
33549                                 Scale uint8
33550
33551                                 //mt:if %s.Flags&TileAlign != 0
33552                                 Align AlignType
33553                         }))(obj)).G
33554                         *p = read8(r)
33555                 }
33556                 {
33557                         p := &(*(*(struct {
33558                                 Texture
33559                                 Anim  TileAnim
33560                                 Flags TileFlags
33561
33562                                 //mt:if %s.Flags&TileColor != 0
33563                                 R, G, B uint8
33564
33565                                 //mt:if %s.Flags&TileScale != 0
33566                                 Scale uint8
33567
33568                                 //mt:if %s.Flags&TileAlign != 0
33569                                 Align AlignType
33570                         }))(obj)).B
33571                         *p = read8(r)
33572                 }
33573         }
33574         if (*(*(struct {
33575                 Texture
33576                 Anim  TileAnim
33577                 Flags TileFlags
33578
33579                 //mt:if %s.Flags&TileColor != 0
33580                 R, G, B uint8
33581
33582                 //mt:if %s.Flags&TileScale != 0
33583                 Scale uint8
33584
33585                 //mt:if %s.Flags&TileAlign != 0
33586                 Align AlignType
33587         }))(obj)).Flags&TileScale != 0 {
33588                 {
33589                         p := &(*(*(struct {
33590                                 Texture
33591                                 Anim  TileAnim
33592                                 Flags TileFlags
33593
33594                                 //mt:if %s.Flags&TileColor != 0
33595                                 R, G, B uint8
33596
33597                                 //mt:if %s.Flags&TileScale != 0
33598                                 Scale uint8
33599
33600                                 //mt:if %s.Flags&TileAlign != 0
33601                                 Align AlignType
33602                         }))(obj)).Scale
33603                         *p = read8(r)
33604                 }
33605         }
33606         if (*(*(struct {
33607                 Texture
33608                 Anim  TileAnim
33609                 Flags TileFlags
33610
33611                 //mt:if %s.Flags&TileColor != 0
33612                 R, G, B uint8
33613
33614                 //mt:if %s.Flags&TileScale != 0
33615                 Scale uint8
33616
33617                 //mt:if %s.Flags&TileAlign != 0
33618                 Align AlignType
33619         }))(obj)).Flags&TileAlign != 0 {
33620                 if err := pcall(func() {
33621                         ((*(*(struct {
33622                                 Texture
33623                                 Anim  TileAnim
33624                                 Flags TileFlags
33625
33626                                 //mt:if %s.Flags&TileColor != 0
33627                                 R, G, B uint8
33628
33629                                 //mt:if %s.Flags&TileScale != 0
33630                                 Scale uint8
33631
33632                                 //mt:if %s.Flags&TileAlign != 0
33633                                 Align AlignType
33634                         }))(obj)).Align).Deserialize(r)
33635                 }); err != nil {
33636                         if err == io.EOF {
33637                                 chk(io.EOF)
33638                         }
33639                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
33640                 }
33641         }
33642 }
33643
33644 func (obj *WaveType) Serialize(w io.Writer) {
33645         {
33646                 x := *(*(uint8))(obj)
33647                 write8(w, uint8(x))
33648         }
33649 }
33650
33651 func (obj *WaveType) Deserialize(r io.Reader) {
33652         {
33653                 p := &*(*(uint8))(obj)
33654                 *p = read8(r)
33655         }
33656 }
33657
33658 func (obj *LiquidType) Serialize(w io.Writer) {
33659         {
33660                 x := *(*(uint8))(obj)
33661                 write8(w, uint8(x))
33662         }
33663 }
33664
33665 func (obj *LiquidType) Deserialize(r io.Reader) {
33666         {
33667                 p := &*(*(uint8))(obj)
33668                 *p = read8(r)
33669         }
33670 }
33671
33672 func (obj *NodeBox) Serialize(w io.Writer) {
33673         {
33674                 local372 := uint8(6)
33675                 {
33676                         x := local372
33677                         write8(w, uint8(x))
33678                 }
33679         }
33680         if err := pcall(func() {
33681                 ((*(*(struct {
33682                         Type NodeBoxType
33683
33684                         //mt:if %s.Type == MountedBox
33685                         WallTop, WallBot, WallSides Box
33686
33687                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33688                         Fixed []Box
33689
33690                         //mt:if %s.Type == ConnectedBox
33691                         ConnDirs, DiscoDirs  DirBoxes
33692                         DiscoAll, DiscoSides []Box
33693                 }))(obj)).Type).Serialize(w)
33694         }); err != nil {
33695                 if err == io.EOF {
33696                         chk(io.EOF)
33697                 }
33698                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
33699         }
33700         if !((*(*(struct {
33701                 Type NodeBoxType
33702
33703                 //mt:if %s.Type == MountedBox
33704                 WallTop, WallBot, WallSides Box
33705
33706                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33707                 Fixed []Box
33708
33709                 //mt:if %s.Type == ConnectedBox
33710                 ConnDirs, DiscoDirs  DirBoxes
33711                 DiscoAll, DiscoSides []Box
33712         }))(obj)).Type < maxBox) {
33713                 chk(errors.New("assertion failed: %s.Type < maxBox"))
33714         }
33715         if (*(*(struct {
33716                 Type NodeBoxType
33717
33718                 //mt:if %s.Type == MountedBox
33719                 WallTop, WallBot, WallSides Box
33720
33721                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33722                 Fixed []Box
33723
33724                 //mt:if %s.Type == ConnectedBox
33725                 ConnDirs, DiscoDirs  DirBoxes
33726                 DiscoAll, DiscoSides []Box
33727         }))(obj)).Type == MountedBox {
33728                 if err := pcall(func() {
33729                         ((*(*(struct {
33730                                 Type NodeBoxType
33731
33732                                 //mt:if %s.Type == MountedBox
33733                                 WallTop, WallBot, WallSides Box
33734
33735                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33736                                 Fixed []Box
33737
33738                                 //mt:if %s.Type == ConnectedBox
33739                                 ConnDirs, DiscoDirs  DirBoxes
33740                                 DiscoAll, DiscoSides []Box
33741                         }))(obj)).WallTop).Serialize(w)
33742                 }); err != nil {
33743                         if err == io.EOF {
33744                                 chk(io.EOF)
33745                         }
33746                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33747                 }
33748                 if err := pcall(func() {
33749                         ((*(*(struct {
33750                                 Type NodeBoxType
33751
33752                                 //mt:if %s.Type == MountedBox
33753                                 WallTop, WallBot, WallSides Box
33754
33755                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33756                                 Fixed []Box
33757
33758                                 //mt:if %s.Type == ConnectedBox
33759                                 ConnDirs, DiscoDirs  DirBoxes
33760                                 DiscoAll, DiscoSides []Box
33761                         }))(obj)).WallBot).Serialize(w)
33762                 }); err != nil {
33763                         if err == io.EOF {
33764                                 chk(io.EOF)
33765                         }
33766                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33767                 }
33768                 if err := pcall(func() {
33769                         ((*(*(struct {
33770                                 Type NodeBoxType
33771
33772                                 //mt:if %s.Type == MountedBox
33773                                 WallTop, WallBot, WallSides Box
33774
33775                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33776                                 Fixed []Box
33777
33778                                 //mt:if %s.Type == ConnectedBox
33779                                 ConnDirs, DiscoDirs  DirBoxes
33780                                 DiscoAll, DiscoSides []Box
33781                         }))(obj)).WallSides).Serialize(w)
33782                 }); err != nil {
33783                         if err == io.EOF {
33784                                 chk(io.EOF)
33785                         }
33786                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33787                 }
33788         }
33789         if t := (*(*(struct {
33790                 Type NodeBoxType
33791
33792                 //mt:if %s.Type == MountedBox
33793                 WallTop, WallBot, WallSides Box
33794
33795                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33796                 Fixed []Box
33797
33798                 //mt:if %s.Type == ConnectedBox
33799                 ConnDirs, DiscoDirs  DirBoxes
33800                 DiscoAll, DiscoSides []Box
33801         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
33802                 if len(((*(*(struct {
33803                         Type NodeBoxType
33804
33805                         //mt:if %s.Type == MountedBox
33806                         WallTop, WallBot, WallSides Box
33807
33808                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33809                         Fixed []Box
33810
33811                         //mt:if %s.Type == ConnectedBox
33812                         ConnDirs, DiscoDirs  DirBoxes
33813                         DiscoAll, DiscoSides []Box
33814                 }))(obj)).Fixed)) > math.MaxUint16 {
33815                         chk(ErrTooLong)
33816                 }
33817                 {
33818                         x := uint16(len(((*(*(struct {
33819                                 Type NodeBoxType
33820
33821                                 //mt:if %s.Type == MountedBox
33822                                 WallTop, WallBot, WallSides Box
33823
33824                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33825                                 Fixed []Box
33826
33827                                 //mt:if %s.Type == ConnectedBox
33828                                 ConnDirs, DiscoDirs  DirBoxes
33829                                 DiscoAll, DiscoSides []Box
33830                         }))(obj)).Fixed)))
33831                         write16(w, uint16(x))
33832                 }
33833                 for local373 := range (*(*(struct {
33834                         Type NodeBoxType
33835
33836                         //mt:if %s.Type == MountedBox
33837                         WallTop, WallBot, WallSides Box
33838
33839                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33840                         Fixed []Box
33841
33842                         //mt:if %s.Type == ConnectedBox
33843                         ConnDirs, DiscoDirs  DirBoxes
33844                         DiscoAll, DiscoSides []Box
33845                 }))(obj)).Fixed {
33846                         if err := pcall(func() {
33847                                 (((*(*(struct {
33848                                         Type NodeBoxType
33849
33850                                         //mt:if %s.Type == MountedBox
33851                                         WallTop, WallBot, WallSides Box
33852
33853                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33854                                         Fixed []Box
33855
33856                                         //mt:if %s.Type == ConnectedBox
33857                                         ConnDirs, DiscoDirs  DirBoxes
33858                                         DiscoAll, DiscoSides []Box
33859                                 }))(obj)).Fixed)[local373]).Serialize(w)
33860                         }); err != nil {
33861                                 if err == io.EOF {
33862                                         chk(io.EOF)
33863                                 }
33864                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33865                         }
33866                 }
33867         }
33868         if (*(*(struct {
33869                 Type NodeBoxType
33870
33871                 //mt:if %s.Type == MountedBox
33872                 WallTop, WallBot, WallSides Box
33873
33874                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33875                 Fixed []Box
33876
33877                 //mt:if %s.Type == ConnectedBox
33878                 ConnDirs, DiscoDirs  DirBoxes
33879                 DiscoAll, DiscoSides []Box
33880         }))(obj)).Type == ConnectedBox {
33881                 if err := pcall(func() {
33882                         ((*(*(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)).ConnDirs).Serialize(w)
33895                 }); err != nil {
33896                         if err == io.EOF {
33897                                 chk(io.EOF)
33898                         }
33899                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33900                 }
33901                 if err := pcall(func() {
33902                         ((*(*(struct {
33903                                 Type NodeBoxType
33904
33905                                 //mt:if %s.Type == MountedBox
33906                                 WallTop, WallBot, WallSides Box
33907
33908                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33909                                 Fixed []Box
33910
33911                                 //mt:if %s.Type == ConnectedBox
33912                                 ConnDirs, DiscoDirs  DirBoxes
33913                                 DiscoAll, DiscoSides []Box
33914                         }))(obj)).DiscoDirs).Serialize(w)
33915                 }); err != nil {
33916                         if err == io.EOF {
33917                                 chk(io.EOF)
33918                         }
33919                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33920                 }
33921                 if len(((*(*(struct {
33922                         Type NodeBoxType
33923
33924                         //mt:if %s.Type == MountedBox
33925                         WallTop, WallBot, WallSides Box
33926
33927                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33928                         Fixed []Box
33929
33930                         //mt:if %s.Type == ConnectedBox
33931                         ConnDirs, DiscoDirs  DirBoxes
33932                         DiscoAll, DiscoSides []Box
33933                 }))(obj)).DiscoAll)) > math.MaxUint16 {
33934                         chk(ErrTooLong)
33935                 }
33936                 {
33937                         x := uint16(len(((*(*(struct {
33938                                 Type NodeBoxType
33939
33940                                 //mt:if %s.Type == MountedBox
33941                                 WallTop, WallBot, WallSides Box
33942
33943                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33944                                 Fixed []Box
33945
33946                                 //mt:if %s.Type == ConnectedBox
33947                                 ConnDirs, DiscoDirs  DirBoxes
33948                                 DiscoAll, DiscoSides []Box
33949                         }))(obj)).DiscoAll)))
33950                         write16(w, uint16(x))
33951                 }
33952                 for local374 := range (*(*(struct {
33953                         Type NodeBoxType
33954
33955                         //mt:if %s.Type == MountedBox
33956                         WallTop, WallBot, WallSides Box
33957
33958                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33959                         Fixed []Box
33960
33961                         //mt:if %s.Type == ConnectedBox
33962                         ConnDirs, DiscoDirs  DirBoxes
33963                         DiscoAll, DiscoSides []Box
33964                 }))(obj)).DiscoAll {
33965                         if err := pcall(func() {
33966                                 (((*(*(struct {
33967                                         Type NodeBoxType
33968
33969                                         //mt:if %s.Type == MountedBox
33970                                         WallTop, WallBot, WallSides Box
33971
33972                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33973                                         Fixed []Box
33974
33975                                         //mt:if %s.Type == ConnectedBox
33976                                         ConnDirs, DiscoDirs  DirBoxes
33977                                         DiscoAll, DiscoSides []Box
33978                                 }))(obj)).DiscoAll)[local374]).Serialize(w)
33979                         }); err != nil {
33980                                 if err == io.EOF {
33981                                         chk(io.EOF)
33982                                 }
33983                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33984                         }
33985                 }
33986                 if len(((*(*(struct {
33987                         Type NodeBoxType
33988
33989                         //mt:if %s.Type == MountedBox
33990                         WallTop, WallBot, WallSides Box
33991
33992                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33993                         Fixed []Box
33994
33995                         //mt:if %s.Type == ConnectedBox
33996                         ConnDirs, DiscoDirs  DirBoxes
33997                         DiscoAll, DiscoSides []Box
33998                 }))(obj)).DiscoSides)) > math.MaxUint16 {
33999                         chk(ErrTooLong)
34000                 }
34001                 {
34002                         x := uint16(len(((*(*(struct {
34003                                 Type NodeBoxType
34004
34005                                 //mt:if %s.Type == MountedBox
34006                                 WallTop, WallBot, WallSides Box
34007
34008                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34009                                 Fixed []Box
34010
34011                                 //mt:if %s.Type == ConnectedBox
34012                                 ConnDirs, DiscoDirs  DirBoxes
34013                                 DiscoAll, DiscoSides []Box
34014                         }))(obj)).DiscoSides)))
34015                         write16(w, uint16(x))
34016                 }
34017                 for local375 := range (*(*(struct {
34018                         Type NodeBoxType
34019
34020                         //mt:if %s.Type == MountedBox
34021                         WallTop, WallBot, WallSides Box
34022
34023                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34024                         Fixed []Box
34025
34026                         //mt:if %s.Type == ConnectedBox
34027                         ConnDirs, DiscoDirs  DirBoxes
34028                         DiscoAll, DiscoSides []Box
34029                 }))(obj)).DiscoSides {
34030                         if err := pcall(func() {
34031                                 (((*(*(struct {
34032                                         Type NodeBoxType
34033
34034                                         //mt:if %s.Type == MountedBox
34035                                         WallTop, WallBot, WallSides Box
34036
34037                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34038                                         Fixed []Box
34039
34040                                         //mt:if %s.Type == ConnectedBox
34041                                         ConnDirs, DiscoDirs  DirBoxes
34042                                         DiscoAll, DiscoSides []Box
34043                                 }))(obj)).DiscoSides)[local375]).Serialize(w)
34044                         }); err != nil {
34045                                 if err == io.EOF {
34046                                         chk(io.EOF)
34047                                 }
34048                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34049                         }
34050                 }
34051         }
34052 }
34053
34054 func (obj *NodeBox) Deserialize(r io.Reader) {
34055         {
34056                 var local376 uint8
34057                 local377 := uint8(6)
34058                 {
34059                         p := &local376
34060                         *p = read8(r)
34061                 }
34062                 if local376 != local377 {
34063                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local376))
34064                 }
34065         }
34066         if err := pcall(func() {
34067                 ((*(*(struct {
34068                         Type NodeBoxType
34069
34070                         //mt:if %s.Type == MountedBox
34071                         WallTop, WallBot, WallSides Box
34072
34073                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34074                         Fixed []Box
34075
34076                         //mt:if %s.Type == ConnectedBox
34077                         ConnDirs, DiscoDirs  DirBoxes
34078                         DiscoAll, DiscoSides []Box
34079                 }))(obj)).Type).Deserialize(r)
34080         }); err != nil {
34081                 if err == io.EOF {
34082                         chk(io.EOF)
34083                 }
34084                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
34085         }
34086         if !((*(*(struct {
34087                 Type NodeBoxType
34088
34089                 //mt:if %s.Type == MountedBox
34090                 WallTop, WallBot, WallSides Box
34091
34092                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34093                 Fixed []Box
34094
34095                 //mt:if %s.Type == ConnectedBox
34096                 ConnDirs, DiscoDirs  DirBoxes
34097                 DiscoAll, DiscoSides []Box
34098         }))(obj)).Type < maxBox) {
34099                 chk(errors.New("assertion failed: %s.Type < maxBox"))
34100         }
34101         if (*(*(struct {
34102                 Type NodeBoxType
34103
34104                 //mt:if %s.Type == MountedBox
34105                 WallTop, WallBot, WallSides Box
34106
34107                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34108                 Fixed []Box
34109
34110                 //mt:if %s.Type == ConnectedBox
34111                 ConnDirs, DiscoDirs  DirBoxes
34112                 DiscoAll, DiscoSides []Box
34113         }))(obj)).Type == MountedBox {
34114                 if err := pcall(func() {
34115                         ((*(*(struct {
34116                                 Type NodeBoxType
34117
34118                                 //mt:if %s.Type == MountedBox
34119                                 WallTop, WallBot, WallSides Box
34120
34121                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34122                                 Fixed []Box
34123
34124                                 //mt:if %s.Type == ConnectedBox
34125                                 ConnDirs, DiscoDirs  DirBoxes
34126                                 DiscoAll, DiscoSides []Box
34127                         }))(obj)).WallTop).Deserialize(r)
34128                 }); err != nil {
34129                         if err == io.EOF {
34130                                 chk(io.EOF)
34131                         }
34132                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34133                 }
34134                 if err := pcall(func() {
34135                         ((*(*(struct {
34136                                 Type NodeBoxType
34137
34138                                 //mt:if %s.Type == MountedBox
34139                                 WallTop, WallBot, WallSides Box
34140
34141                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34142                                 Fixed []Box
34143
34144                                 //mt:if %s.Type == ConnectedBox
34145                                 ConnDirs, DiscoDirs  DirBoxes
34146                                 DiscoAll, DiscoSides []Box
34147                         }))(obj)).WallBot).Deserialize(r)
34148                 }); err != nil {
34149                         if err == io.EOF {
34150                                 chk(io.EOF)
34151                         }
34152                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34153                 }
34154                 if err := pcall(func() {
34155                         ((*(*(struct {
34156                                 Type NodeBoxType
34157
34158                                 //mt:if %s.Type == MountedBox
34159                                 WallTop, WallBot, WallSides Box
34160
34161                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34162                                 Fixed []Box
34163
34164                                 //mt:if %s.Type == ConnectedBox
34165                                 ConnDirs, DiscoDirs  DirBoxes
34166                                 DiscoAll, DiscoSides []Box
34167                         }))(obj)).WallSides).Deserialize(r)
34168                 }); err != nil {
34169                         if err == io.EOF {
34170                                 chk(io.EOF)
34171                         }
34172                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34173                 }
34174         }
34175         if t := (*(*(struct {
34176                 Type NodeBoxType
34177
34178                 //mt:if %s.Type == MountedBox
34179                 WallTop, WallBot, WallSides Box
34180
34181                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34182                 Fixed []Box
34183
34184                 //mt:if %s.Type == ConnectedBox
34185                 ConnDirs, DiscoDirs  DirBoxes
34186                 DiscoAll, DiscoSides []Box
34187         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
34188                 var local378 uint16
34189                 {
34190                         p := &local378
34191                         *p = read16(r)
34192                 }
34193                 ((*(*(struct {
34194                         Type NodeBoxType
34195
34196                         //mt:if %s.Type == MountedBox
34197                         WallTop, WallBot, WallSides Box
34198
34199                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34200                         Fixed []Box
34201
34202                         //mt:if %s.Type == ConnectedBox
34203                         ConnDirs, DiscoDirs  DirBoxes
34204                         DiscoAll, DiscoSides []Box
34205                 }))(obj)).Fixed) = make([]Box, local378)
34206                 for local379 := range (*(*(struct {
34207                         Type NodeBoxType
34208
34209                         //mt:if %s.Type == MountedBox
34210                         WallTop, WallBot, WallSides Box
34211
34212                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34213                         Fixed []Box
34214
34215                         //mt:if %s.Type == ConnectedBox
34216                         ConnDirs, DiscoDirs  DirBoxes
34217                         DiscoAll, DiscoSides []Box
34218                 }))(obj)).Fixed {
34219                         if err := pcall(func() {
34220                                 (((*(*(struct {
34221                                         Type NodeBoxType
34222
34223                                         //mt:if %s.Type == MountedBox
34224                                         WallTop, WallBot, WallSides Box
34225
34226                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34227                                         Fixed []Box
34228
34229                                         //mt:if %s.Type == ConnectedBox
34230                                         ConnDirs, DiscoDirs  DirBoxes
34231                                         DiscoAll, DiscoSides []Box
34232                                 }))(obj)).Fixed)[local379]).Deserialize(r)
34233                         }); err != nil {
34234                                 if err == io.EOF {
34235                                         chk(io.EOF)
34236                                 }
34237                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34238                         }
34239                 }
34240         }
34241         if (*(*(struct {
34242                 Type NodeBoxType
34243
34244                 //mt:if %s.Type == MountedBox
34245                 WallTop, WallBot, WallSides Box
34246
34247                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34248                 Fixed []Box
34249
34250                 //mt:if %s.Type == ConnectedBox
34251                 ConnDirs, DiscoDirs  DirBoxes
34252                 DiscoAll, DiscoSides []Box
34253         }))(obj)).Type == ConnectedBox {
34254                 if err := pcall(func() {
34255                         ((*(*(struct {
34256                                 Type NodeBoxType
34257
34258                                 //mt:if %s.Type == MountedBox
34259                                 WallTop, WallBot, WallSides Box
34260
34261                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34262                                 Fixed []Box
34263
34264                                 //mt:if %s.Type == ConnectedBox
34265                                 ConnDirs, DiscoDirs  DirBoxes
34266                                 DiscoAll, DiscoSides []Box
34267                         }))(obj)).ConnDirs).Deserialize(r)
34268                 }); err != nil {
34269                         if err == io.EOF {
34270                                 chk(io.EOF)
34271                         }
34272                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
34273                 }
34274                 if err := pcall(func() {
34275                         ((*(*(struct {
34276                                 Type NodeBoxType
34277
34278                                 //mt:if %s.Type == MountedBox
34279                                 WallTop, WallBot, WallSides Box
34280
34281                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34282                                 Fixed []Box
34283
34284                                 //mt:if %s.Type == ConnectedBox
34285                                 ConnDirs, DiscoDirs  DirBoxes
34286                                 DiscoAll, DiscoSides []Box
34287                         }))(obj)).DiscoDirs).Deserialize(r)
34288                 }); err != nil {
34289                         if err == io.EOF {
34290                                 chk(io.EOF)
34291                         }
34292                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
34293                 }
34294                 var local380 uint16
34295                 {
34296                         p := &local380
34297                         *p = read16(r)
34298                 }
34299                 ((*(*(struct {
34300                         Type NodeBoxType
34301
34302                         //mt:if %s.Type == MountedBox
34303                         WallTop, WallBot, WallSides Box
34304
34305                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34306                         Fixed []Box
34307
34308                         //mt:if %s.Type == ConnectedBox
34309                         ConnDirs, DiscoDirs  DirBoxes
34310                         DiscoAll, DiscoSides []Box
34311                 }))(obj)).DiscoAll) = make([]Box, local380)
34312                 for local381 := range (*(*(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)).DiscoAll {
34325                         if err := pcall(func() {
34326                                 (((*(*(struct {
34327                                         Type NodeBoxType
34328
34329                                         //mt:if %s.Type == MountedBox
34330                                         WallTop, WallBot, WallSides Box
34331
34332                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34333                                         Fixed []Box
34334
34335                                         //mt:if %s.Type == ConnectedBox
34336                                         ConnDirs, DiscoDirs  DirBoxes
34337                                         DiscoAll, DiscoSides []Box
34338                                 }))(obj)).DiscoAll)[local381]).Deserialize(r)
34339                         }); err != nil {
34340                                 if err == io.EOF {
34341                                         chk(io.EOF)
34342                                 }
34343                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34344                         }
34345                 }
34346                 var local382 uint16
34347                 {
34348                         p := &local382
34349                         *p = read16(r)
34350                 }
34351                 ((*(*(struct {
34352                         Type NodeBoxType
34353
34354                         //mt:if %s.Type == MountedBox
34355                         WallTop, WallBot, WallSides Box
34356
34357                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34358                         Fixed []Box
34359
34360                         //mt:if %s.Type == ConnectedBox
34361                         ConnDirs, DiscoDirs  DirBoxes
34362                         DiscoAll, DiscoSides []Box
34363                 }))(obj)).DiscoSides) = make([]Box, local382)
34364                 for local383 := range (*(*(struct {
34365                         Type NodeBoxType
34366
34367                         //mt:if %s.Type == MountedBox
34368                         WallTop, WallBot, WallSides Box
34369
34370                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34371                         Fixed []Box
34372
34373                         //mt:if %s.Type == ConnectedBox
34374                         ConnDirs, DiscoDirs  DirBoxes
34375                         DiscoAll, DiscoSides []Box
34376                 }))(obj)).DiscoSides {
34377                         if err := pcall(func() {
34378                                 (((*(*(struct {
34379                                         Type NodeBoxType
34380
34381                                         //mt:if %s.Type == MountedBox
34382                                         WallTop, WallBot, WallSides Box
34383
34384                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34385                                         Fixed []Box
34386
34387                                         //mt:if %s.Type == ConnectedBox
34388                                         ConnDirs, DiscoDirs  DirBoxes
34389                                         DiscoAll, DiscoSides []Box
34390                                 }))(obj)).DiscoSides)[local383]).Deserialize(r)
34391                         }); err != nil {
34392                                 if err == io.EOF {
34393                                         chk(io.EOF)
34394                                 }
34395                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34396                         }
34397                 }
34398         }
34399 }
34400
34401 func (obj *SoundDef) Serialize(w io.Writer) {
34402         if len(([]byte((*(*(struct {
34403                 Name              string
34404                 Gain, Pitch, Fade float32
34405         }))(obj)).Name))) > math.MaxUint16 {
34406                 chk(ErrTooLong)
34407         }
34408         {
34409                 x := uint16(len(([]byte((*(*(struct {
34410                         Name              string
34411                         Gain, Pitch, Fade float32
34412                 }))(obj)).Name))))
34413                 write16(w, uint16(x))
34414         }
34415         {
34416                 _, err := w.Write(([]byte((*(*(struct {
34417                         Name              string
34418                         Gain, Pitch, Fade float32
34419                 }))(obj)).Name))[:])
34420                 chk(err)
34421         }
34422         {
34423                 x := (*(*(struct {
34424                         Name              string
34425                         Gain, Pitch, Fade float32
34426                 }))(obj)).Gain
34427                 write32(w, math.Float32bits(x))
34428         }
34429         {
34430                 x := (*(*(struct {
34431                         Name              string
34432                         Gain, Pitch, Fade float32
34433                 }))(obj)).Pitch
34434                 write32(w, math.Float32bits(x))
34435         }
34436         {
34437                 x := (*(*(struct {
34438                         Name              string
34439                         Gain, Pitch, Fade float32
34440                 }))(obj)).Fade
34441                 write32(w, math.Float32bits(x))
34442         }
34443 }
34444
34445 func (obj *SoundDef) Deserialize(r io.Reader) {
34446         var local384 []uint8
34447         var local385 uint16
34448         {
34449                 p := &local385
34450                 *p = read16(r)
34451         }
34452         (local384) = make([]uint8, local385)
34453         {
34454                 _, err := io.ReadFull(r, (local384)[:])
34455                 chk(err)
34456         }
34457         ((*(*(struct {
34458                 Name              string
34459                 Gain, Pitch, Fade float32
34460         }))(obj)).Name) = string(local384)
34461         {
34462                 p := &(*(*(struct {
34463                         Name              string
34464                         Gain, Pitch, Fade float32
34465                 }))(obj)).Gain
34466                 *p = math.Float32frombits(read32(r))
34467         }
34468         {
34469                 p := &(*(*(struct {
34470                         Name              string
34471                         Gain, Pitch, Fade float32
34472                 }))(obj)).Pitch
34473                 *p = math.Float32frombits(read32(r))
34474         }
34475         {
34476                 p := &(*(*(struct {
34477                         Name              string
34478                         Gain, Pitch, Fade float32
34479                 }))(obj)).Fade
34480                 *p = math.Float32frombits(read32(r))
34481         }
34482 }
34483
34484 func (obj *AlphaUse) Serialize(w io.Writer) {
34485         {
34486                 x := *(*(uint8))(obj)
34487                 write8(w, uint8(x))
34488         }
34489 }
34490
34491 func (obj *AlphaUse) Deserialize(r io.Reader) {
34492         {
34493                 p := &*(*(uint8))(obj)
34494                 *p = read8(r)
34495         }
34496 }
34497
34498 func (obj *Keys) Serialize(w io.Writer) {
34499         {
34500                 x := *(*(uint32))(obj)
34501                 write32(w, uint32(x))
34502         }
34503 }
34504
34505 func (obj *Keys) Deserialize(r io.Reader) {
34506         {
34507                 p := &*(*(uint32))(obj)
34508                 *p = read32(r)
34509         }
34510 }
34511
34512 func (obj *MapBlkFlags) Serialize(w io.Writer) {
34513         {
34514                 x := *(*(uint8))(obj)
34515                 write8(w, uint8(x))
34516         }
34517 }
34518
34519 func (obj *MapBlkFlags) Deserialize(r io.Reader) {
34520         {
34521                 p := &*(*(uint8))(obj)
34522                 *p = read8(r)
34523         }
34524 }
34525
34526 func (obj *LitFromBlks) Serialize(w io.Writer) {
34527         {
34528                 x := *(*(uint16))(obj)
34529                 write16(w, uint16(x))
34530         }
34531 }
34532
34533 func (obj *LitFromBlks) Deserialize(r io.Reader) {
34534         {
34535                 p := &*(*(uint16))(obj)
34536                 *p = read16(r)
34537         }
34538 }
34539
34540 func (obj *AOInitData) Serialize(w io.Writer) {
34541         {
34542                 local386 := uint8(1)
34543                 {
34544                         x := local386
34545                         write8(w, uint8(x))
34546                 }
34547         }
34548         if len(([]byte((*(*(struct {
34549
34550                 // For players.
34551                 Name     string
34552                 IsPlayer bool
34553
34554                 ID AOID
34555
34556                 Pos
34557                 Rot [3]float32
34558
34559                 HP uint16
34560
34561                 // See (de)serialize.fmt.
34562                 Msgs []AOMsg
34563         }))(obj)).Name))) > math.MaxUint16 {
34564                 chk(ErrTooLong)
34565         }
34566         {
34567                 x := uint16(len(([]byte((*(*(struct {
34568
34569                         // For players.
34570                         Name     string
34571                         IsPlayer bool
34572
34573                         ID AOID
34574
34575                         Pos
34576                         Rot [3]float32
34577
34578                         HP uint16
34579
34580                         // See (de)serialize.fmt.
34581                         Msgs []AOMsg
34582                 }))(obj)).Name))))
34583                 write16(w, uint16(x))
34584         }
34585         {
34586                 _, err := w.Write(([]byte((*(*(struct {
34587
34588                         // For players.
34589                         Name     string
34590                         IsPlayer bool
34591
34592                         ID AOID
34593
34594                         Pos
34595                         Rot [3]float32
34596
34597                         HP uint16
34598
34599                         // See (de)serialize.fmt.
34600                         Msgs []AOMsg
34601                 }))(obj)).Name))[:])
34602                 chk(err)
34603         }
34604         {
34605                 x := (*(*(struct {
34606
34607                         // For players.
34608                         Name     string
34609                         IsPlayer bool
34610
34611                         ID AOID
34612
34613                         Pos
34614                         Rot [3]float32
34615
34616                         HP uint16
34617
34618                         // See (de)serialize.fmt.
34619                         Msgs []AOMsg
34620                 }))(obj)).IsPlayer
34621                 if x {
34622                         write8(w, 1)
34623                 } else {
34624                         write8(w, 0)
34625                 }
34626         }
34627         if err := pcall(func() {
34628                 ((*(*(struct {
34629
34630                         // For players.
34631                         Name     string
34632                         IsPlayer bool
34633
34634                         ID AOID
34635
34636                         Pos
34637                         Rot [3]float32
34638
34639                         HP uint16
34640
34641                         // See (de)serialize.fmt.
34642                         Msgs []AOMsg
34643                 }))(obj)).ID).Serialize(w)
34644         }); err != nil {
34645                 if err == io.EOF {
34646                         chk(io.EOF)
34647                 }
34648                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
34649         }
34650         if err := pcall(func() {
34651                 ((*(*(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)).Pos).Serialize(w)
34667         }); err != nil {
34668                 if err == io.EOF {
34669                         chk(io.EOF)
34670                 }
34671                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
34672         }
34673         for local387 := range (*(*(struct {
34674
34675                 // For players.
34676                 Name     string
34677                 IsPlayer bool
34678
34679                 ID AOID
34680
34681                 Pos
34682                 Rot [3]float32
34683
34684                 HP uint16
34685
34686                 // See (de)serialize.fmt.
34687                 Msgs []AOMsg
34688         }))(obj)).Rot {
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)).Rot)[local387]
34706                         write32(w, math.Float32bits(x))
34707                 }
34708         }
34709         {
34710                 x := (*(*(struct {
34711
34712                         // For players.
34713                         Name     string
34714                         IsPlayer bool
34715
34716                         ID AOID
34717
34718                         Pos
34719                         Rot [3]float32
34720
34721                         HP uint16
34722
34723                         // See (de)serialize.fmt.
34724                         Msgs []AOMsg
34725                 }))(obj)).HP
34726                 write16(w, uint16(x))
34727         }
34728         {
34729                 x := (*(*(struct {
34730
34731                         // For players.
34732                         Name     string
34733                         IsPlayer bool
34734
34735                         ID AOID
34736
34737                         Pos
34738                         Rot [3]float32
34739
34740                         HP uint16
34741
34742                         // See (de)serialize.fmt.
34743                         Msgs []AOMsg
34744                 }))(obj)).Msgs
34745                 { // For AOInitData.Msgs.
34746                         if len(x) > math.MaxUint8 {
34747                                 chk(ErrTooLong)
34748                         }
34749                         write8(w, uint8(len(x)))
34750                         for _, msg := range x {
34751                                 var b bytes.Buffer
34752                                 chk(writeAOMsg(&b, msg))
34753                                 if b.Len() > math.MaxUint32 {
34754                                         chk(ErrTooLong)
34755                                 }
34756                                 write32(w, uint32(b.Len()))
34757                                 _, err := b.WriteTo(w)
34758                                 chk(err)
34759                         }
34760                 }
34761         }
34762 }
34763
34764 func (obj *AOInitData) Deserialize(r io.Reader) {
34765         {
34766                 var local388 uint8
34767                 local389 := uint8(1)
34768                 {
34769                         p := &local388
34770                         *p = read8(r)
34771                 }
34772                 if local388 != local389 {
34773                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local388))
34774                 }
34775         }
34776         var local390 []uint8
34777         var local391 uint16
34778         {
34779                 p := &local391
34780                 *p = read16(r)
34781         }
34782         (local390) = make([]uint8, local391)
34783         {
34784                 _, err := io.ReadFull(r, (local390)[:])
34785                 chk(err)
34786         }
34787         ((*(*(struct {
34788
34789                 // For players.
34790                 Name     string
34791                 IsPlayer bool
34792
34793                 ID AOID
34794
34795                 Pos
34796                 Rot [3]float32
34797
34798                 HP uint16
34799
34800                 // See (de)serialize.fmt.
34801                 Msgs []AOMsg
34802         }))(obj)).Name) = string(local390)
34803         {
34804                 p := &(*(*(struct {
34805
34806                         // For players.
34807                         Name     string
34808                         IsPlayer bool
34809
34810                         ID AOID
34811
34812                         Pos
34813                         Rot [3]float32
34814
34815                         HP uint16
34816
34817                         // See (de)serialize.fmt.
34818                         Msgs []AOMsg
34819                 }))(obj)).IsPlayer
34820                 switch n := read8(r); n {
34821                 case 0:
34822                         *p = false
34823                 case 1:
34824                         *p = true
34825                 default:
34826                         chk(fmt.Errorf("invalid bool: %d", n))
34827                 }
34828         }
34829         if err := pcall(func() {
34830                 ((*(*(struct {
34831
34832                         // For players.
34833                         Name     string
34834                         IsPlayer bool
34835
34836                         ID AOID
34837
34838                         Pos
34839                         Rot [3]float32
34840
34841                         HP uint16
34842
34843                         // See (de)serialize.fmt.
34844                         Msgs []AOMsg
34845                 }))(obj)).ID).Deserialize(r)
34846         }); err != nil {
34847                 if err == io.EOF {
34848                         chk(io.EOF)
34849                 }
34850                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
34851         }
34852         if err := pcall(func() {
34853                 ((*(*(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)).Pos).Deserialize(r)
34869         }); err != nil {
34870                 if err == io.EOF {
34871                         chk(io.EOF)
34872                 }
34873                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
34874         }
34875         for local392 := range (*(*(struct {
34876
34877                 // For players.
34878                 Name     string
34879                 IsPlayer bool
34880
34881                 ID AOID
34882
34883                 Pos
34884                 Rot [3]float32
34885
34886                 HP uint16
34887
34888                 // See (de)serialize.fmt.
34889                 Msgs []AOMsg
34890         }))(obj)).Rot {
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)).Rot)[local392]
34908                         *p = math.Float32frombits(read32(r))
34909                 }
34910         }
34911         {
34912                 p := &(*(*(struct {
34913
34914                         // For players.
34915                         Name     string
34916                         IsPlayer bool
34917
34918                         ID AOID
34919
34920                         Pos
34921                         Rot [3]float32
34922
34923                         HP uint16
34924
34925                         // See (de)serialize.fmt.
34926                         Msgs []AOMsg
34927                 }))(obj)).HP
34928                 *p = read16(r)
34929         }
34930         {
34931                 p := &(*(*(struct {
34932
34933                         // For players.
34934                         Name     string
34935                         IsPlayer bool
34936
34937                         ID AOID
34938
34939                         Pos
34940                         Rot [3]float32
34941
34942                         HP uint16
34943
34944                         // See (de)serialize.fmt.
34945                         Msgs []AOMsg
34946                 }))(obj)).Msgs
34947                 { // For AOInitData.Msgs.
34948                         *p = make([]AOMsg, read8(r))
34949                         for i := range *p {
34950                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
34951                                 msg, err := readAOMsg(r)
34952                                 chk(err)
34953                                 (*p)[i] = msg
34954                                 if r.N > 0 {
34955                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34956                                 }
34957                         }
34958                 }
34959         }
34960 }
34961
34962 func (obj *ItemType) Serialize(w io.Writer) {
34963         {
34964                 x := *(*(uint8))(obj)
34965                 write8(w, uint8(x))
34966         }
34967 }
34968
34969 func (obj *ItemType) Deserialize(r io.Reader) {
34970         {
34971                 p := &*(*(uint8))(obj)
34972                 *p = read8(r)
34973         }
34974 }
34975
34976 func (obj *ToolCaps) Serialize(w io.Writer) {
34977         if _ = (*(*(struct {
34978                 //mt:if _ = %s; false
34979                 NonNil bool
34980
34981                 AttackCooldown float32
34982                 MaxDropLvl     int16
34983
34984                 //mt:len32
34985                 GroupCaps []ToolGroupCap
34986
34987                 //mt:len32
34988                 DmgGroups []Group
34989
34990                 //mt:32tou16
34991                 PunchUses int32
34992         }))(obj)); false {
34993                 {
34994                         x := (*(*(struct {
34995                                 //mt:if _ = %s; false
34996                                 NonNil bool
34997
34998                                 AttackCooldown float32
34999                                 MaxDropLvl     int16
35000
35001                                 //mt:len32
35002                                 GroupCaps []ToolGroupCap
35003
35004                                 //mt:len32
35005                                 DmgGroups []Group
35006
35007                                 //mt:32tou16
35008                                 PunchUses int32
35009                         }))(obj)).NonNil
35010                         if x {
35011                                 write8(w, 1)
35012                         } else {
35013                                 write8(w, 0)
35014                         }
35015                 }
35016         }
35017         {
35018                 ow := w
35019                 w := new(bytes.Buffer)
35020                 /*
35021                         if r.N > 0 { (*(*(struct {
35022                                 //mt:if _ = %s; false
35023                                 NonNil  bool
35024
35025                                 AttackCooldown  float32
35026                                 MaxDropLvl      int16
35027
35028                                 //mt:len32
35029                                 GroupCaps       []ToolGroupCap
35030
35031                                 //mt:len32
35032                                 DmgGroups       []Group
35033
35034                                 //mt:32tou16
35035                                 PunchUses       int32
35036                         }))(obj)).NonNil = true}; /*
35037                 */{
35038                         if (*(*(struct {
35039                                 //mt:if _ = %s; false
35040                                 NonNil bool
35041
35042                                 AttackCooldown float32
35043                                 MaxDropLvl     int16
35044
35045                                 //mt:len32
35046                                 GroupCaps []ToolGroupCap
35047
35048                                 //mt:len32
35049                                 DmgGroups []Group
35050
35051                                 //mt:32tou16
35052                                 PunchUses int32
35053                         }))(obj)).NonNil {
35054                                 {
35055                                         local393 := uint8(5)
35056                                         {
35057                                                 x := local393
35058                                                 write8(w, uint8(x))
35059                                         }
35060                                 }
35061                                 {
35062                                         x := (*(*(struct {
35063                                                 //mt:if _ = %s; false
35064                                                 NonNil bool
35065
35066                                                 AttackCooldown float32
35067                                                 MaxDropLvl     int16
35068
35069                                                 //mt:len32
35070                                                 GroupCaps []ToolGroupCap
35071
35072                                                 //mt:len32
35073                                                 DmgGroups []Group
35074
35075                                                 //mt:32tou16
35076                                                 PunchUses int32
35077                                         }))(obj)).AttackCooldown
35078                                         write32(w, math.Float32bits(x))
35079                                 }
35080                                 {
35081                                         x := (*(*(struct {
35082                                                 //mt:if _ = %s; false
35083                                                 NonNil bool
35084
35085                                                 AttackCooldown float32
35086                                                 MaxDropLvl     int16
35087
35088                                                 //mt:len32
35089                                                 GroupCaps []ToolGroupCap
35090
35091                                                 //mt:len32
35092                                                 DmgGroups []Group
35093
35094                                                 //mt:32tou16
35095                                                 PunchUses int32
35096                                         }))(obj)).MaxDropLvl
35097                                         write16(w, uint16(x))
35098                                 }
35099                                 if len(((*(*(struct {
35100                                         //mt:if _ = %s; false
35101                                         NonNil bool
35102
35103                                         AttackCooldown float32
35104                                         MaxDropLvl     int16
35105
35106                                         //mt:len32
35107                                         GroupCaps []ToolGroupCap
35108
35109                                         //mt:len32
35110                                         DmgGroups []Group
35111
35112                                         //mt:32tou16
35113                                         PunchUses int32
35114                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
35115                                         chk(ErrTooLong)
35116                                 }
35117                                 {
35118                                         x := uint32(len(((*(*(struct {
35119                                                 //mt:if _ = %s; false
35120                                                 NonNil bool
35121
35122                                                 AttackCooldown float32
35123                                                 MaxDropLvl     int16
35124
35125                                                 //mt:len32
35126                                                 GroupCaps []ToolGroupCap
35127
35128                                                 //mt:len32
35129                                                 DmgGroups []Group
35130
35131                                                 //mt:32tou16
35132                                                 PunchUses int32
35133                                         }))(obj)).GroupCaps)))
35134                                         write32(w, uint32(x))
35135                                 }
35136                                 for local394 := range (*(*(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)).GroupCaps {
35152                                         if err := pcall(func() {
35153                                                 (((*(*(struct {
35154                                                         //mt:if _ = %s; false
35155                                                         NonNil bool
35156
35157                                                         AttackCooldown float32
35158                                                         MaxDropLvl     int16
35159
35160                                                         //mt:len32
35161                                                         GroupCaps []ToolGroupCap
35162
35163                                                         //mt:len32
35164                                                         DmgGroups []Group
35165
35166                                                         //mt:32tou16
35167                                                         PunchUses int32
35168                                                 }))(obj)).GroupCaps)[local394]).Serialize(w)
35169                                         }); err != nil {
35170                                                 if err == io.EOF {
35171                                                         chk(io.EOF)
35172                                                 }
35173                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
35174                                         }
35175                                 }
35176                                 if len(((*(*(struct {
35177                                         //mt:if _ = %s; false
35178                                         NonNil bool
35179
35180                                         AttackCooldown float32
35181                                         MaxDropLvl     int16
35182
35183                                         //mt:len32
35184                                         GroupCaps []ToolGroupCap
35185
35186                                         //mt:len32
35187                                         DmgGroups []Group
35188
35189                                         //mt:32tou16
35190                                         PunchUses int32
35191                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
35192                                         chk(ErrTooLong)
35193                                 }
35194                                 {
35195                                         x := uint32(len(((*(*(struct {
35196                                                 //mt:if _ = %s; false
35197                                                 NonNil bool
35198
35199                                                 AttackCooldown float32
35200                                                 MaxDropLvl     int16
35201
35202                                                 //mt:len32
35203                                                 GroupCaps []ToolGroupCap
35204
35205                                                 //mt:len32
35206                                                 DmgGroups []Group
35207
35208                                                 //mt:32tou16
35209                                                 PunchUses int32
35210                                         }))(obj)).DmgGroups)))
35211                                         write32(w, uint32(x))
35212                                 }
35213                                 for local395 := range (*(*(struct {
35214                                         //mt:if _ = %s; false
35215                                         NonNil bool
35216
35217                                         AttackCooldown float32
35218                                         MaxDropLvl     int16
35219
35220                                         //mt:len32
35221                                         GroupCaps []ToolGroupCap
35222
35223                                         //mt:len32
35224                                         DmgGroups []Group
35225
35226                                         //mt:32tou16
35227                                         PunchUses int32
35228                                 }))(obj)).DmgGroups {
35229                                         if err := pcall(func() {
35230                                                 (((*(*(struct {
35231                                                         //mt:if _ = %s; false
35232                                                         NonNil bool
35233
35234                                                         AttackCooldown float32
35235                                                         MaxDropLvl     int16
35236
35237                                                         //mt:len32
35238                                                         GroupCaps []ToolGroupCap
35239
35240                                                         //mt:len32
35241                                                         DmgGroups []Group
35242
35243                                                         //mt:32tou16
35244                                                         PunchUses int32
35245                                                 }))(obj)).DmgGroups)[local395]).Serialize(w)
35246                                         }); err != nil {
35247                                                 if err == io.EOF {
35248                                                         chk(io.EOF)
35249                                                 }
35250                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
35251                                         }
35252                                 }
35253                                 {
35254                                         x := uint16((*(*(struct {
35255                                                 //mt:if _ = %s; false
35256                                                 NonNil bool
35257
35258                                                 AttackCooldown float32
35259                                                 MaxDropLvl     int16
35260
35261                                                 //mt:len32
35262                                                 GroupCaps []ToolGroupCap
35263
35264                                                 //mt:len32
35265                                                 DmgGroups []Group
35266
35267                                                 //mt:32tou16
35268                                                 PunchUses int32
35269                                         }))(obj)).PunchUses)
35270                                         write16(w, uint16(x))
35271                                 }
35272                         }
35273                 }
35274                 {
35275                         buf := w
35276                         w := ow
35277                         if len((buf.Bytes())) > math.MaxUint16 {
35278                                 chk(ErrTooLong)
35279                         }
35280                         {
35281                                 x := uint16(len((buf.Bytes())))
35282                                 write16(w, uint16(x))
35283                         }
35284                         {
35285                                 _, err := w.Write((buf.Bytes())[:])
35286                                 chk(err)
35287                         }
35288                 }
35289         }
35290 }
35291
35292 func (obj *ToolCaps) Deserialize(r io.Reader) {
35293         if _ = (*(*(struct {
35294                 //mt:if _ = %s; false
35295                 NonNil bool
35296
35297                 AttackCooldown float32
35298                 MaxDropLvl     int16
35299
35300                 //mt:len32
35301                 GroupCaps []ToolGroupCap
35302
35303                 //mt:len32
35304                 DmgGroups []Group
35305
35306                 //mt:32tou16
35307                 PunchUses int32
35308         }))(obj)); false {
35309                 {
35310                         p := &(*(*(struct {
35311                                 //mt:if _ = %s; false
35312                                 NonNil bool
35313
35314                                 AttackCooldown float32
35315                                 MaxDropLvl     int16
35316
35317                                 //mt:len32
35318                                 GroupCaps []ToolGroupCap
35319
35320                                 //mt:len32
35321                                 DmgGroups []Group
35322
35323                                 //mt:32tou16
35324                                 PunchUses int32
35325                         }))(obj)).NonNil
35326                         switch n := read8(r); n {
35327                         case 0:
35328                                 *p = false
35329                         case 1:
35330                                 *p = true
35331                         default:
35332                                 chk(fmt.Errorf("invalid bool: %d", n))
35333                         }
35334                 }
35335         }
35336         {
35337                 var n uint16
35338                 {
35339                         p := &n
35340                         *p = read16(r)
35341                 }
35342                 r := &io.LimitedReader{R: r, N: int64(n)}
35343                 if r.N > 0 {
35344                         (*(*(struct {
35345                                 //mt:if _ = %s; false
35346                                 NonNil bool
35347
35348                                 AttackCooldown float32
35349                                 MaxDropLvl     int16
35350
35351                                 //mt:len32
35352                                 GroupCaps []ToolGroupCap
35353
35354                                 //mt:len32
35355                                 DmgGroups []Group
35356
35357                                 //mt:32tou16
35358                                 PunchUses int32
35359                         }))(obj)).NonNil = true
35360                 } /**/
35361                 {
35362                         if (*(*(struct {
35363                                 //mt:if _ = %s; false
35364                                 NonNil bool
35365
35366                                 AttackCooldown float32
35367                                 MaxDropLvl     int16
35368
35369                                 //mt:len32
35370                                 GroupCaps []ToolGroupCap
35371
35372                                 //mt:len32
35373                                 DmgGroups []Group
35374
35375                                 //mt:32tou16
35376                                 PunchUses int32
35377                         }))(obj)).NonNil {
35378                                 {
35379                                         var local396 uint8
35380                                         local397 := uint8(5)
35381                                         {
35382                                                 p := &local396
35383                                                 *p = read8(r)
35384                                         }
35385                                         if local396 != local397 {
35386                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local396))
35387                                         }
35388                                 }
35389                                 {
35390                                         p := &(*(*(struct {
35391                                                 //mt:if _ = %s; false
35392                                                 NonNil bool
35393
35394                                                 AttackCooldown float32
35395                                                 MaxDropLvl     int16
35396
35397                                                 //mt:len32
35398                                                 GroupCaps []ToolGroupCap
35399
35400                                                 //mt:len32
35401                                                 DmgGroups []Group
35402
35403                                                 //mt:32tou16
35404                                                 PunchUses int32
35405                                         }))(obj)).AttackCooldown
35406                                         *p = math.Float32frombits(read32(r))
35407                                 }
35408                                 {
35409                                         p := &(*(*(struct {
35410                                                 //mt:if _ = %s; false
35411                                                 NonNil bool
35412
35413                                                 AttackCooldown float32
35414                                                 MaxDropLvl     int16
35415
35416                                                 //mt:len32
35417                                                 GroupCaps []ToolGroupCap
35418
35419                                                 //mt:len32
35420                                                 DmgGroups []Group
35421
35422                                                 //mt:32tou16
35423                                                 PunchUses int32
35424                                         }))(obj)).MaxDropLvl
35425                                         *p = int16(read16(r))
35426                                 }
35427                                 var local398 uint32
35428                                 {
35429                                         p := &local398
35430                                         *p = read32(r)
35431                                 }
35432                                 ((*(*(struct {
35433                                         //mt:if _ = %s; false
35434                                         NonNil bool
35435
35436                                         AttackCooldown float32
35437                                         MaxDropLvl     int16
35438
35439                                         //mt:len32
35440                                         GroupCaps []ToolGroupCap
35441
35442                                         //mt:len32
35443                                         DmgGroups []Group
35444
35445                                         //mt:32tou16
35446                                         PunchUses int32
35447                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local398)
35448                                 for local399 := range (*(*(struct {
35449                                         //mt:if _ = %s; false
35450                                         NonNil bool
35451
35452                                         AttackCooldown float32
35453                                         MaxDropLvl     int16
35454
35455                                         //mt:len32
35456                                         GroupCaps []ToolGroupCap
35457
35458                                         //mt:len32
35459                                         DmgGroups []Group
35460
35461                                         //mt:32tou16
35462                                         PunchUses int32
35463                                 }))(obj)).GroupCaps {
35464                                         if err := pcall(func() {
35465                                                 (((*(*(struct {
35466                                                         //mt:if _ = %s; false
35467                                                         NonNil bool
35468
35469                                                         AttackCooldown float32
35470                                                         MaxDropLvl     int16
35471
35472                                                         //mt:len32
35473                                                         GroupCaps []ToolGroupCap
35474
35475                                                         //mt:len32
35476                                                         DmgGroups []Group
35477
35478                                                         //mt:32tou16
35479                                                         PunchUses int32
35480                                                 }))(obj)).GroupCaps)[local399]).Deserialize(r)
35481                                         }); err != nil {
35482                                                 if err == io.EOF {
35483                                                         chk(io.EOF)
35484                                                 }
35485                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
35486                                         }
35487                                 }
35488                                 var local400 uint32
35489                                 {
35490                                         p := &local400
35491                                         *p = read32(r)
35492                                 }
35493                                 ((*(*(struct {
35494                                         //mt:if _ = %s; false
35495                                         NonNil bool
35496
35497                                         AttackCooldown float32
35498                                         MaxDropLvl     int16
35499
35500                                         //mt:len32
35501                                         GroupCaps []ToolGroupCap
35502
35503                                         //mt:len32
35504                                         DmgGroups []Group
35505
35506                                         //mt:32tou16
35507                                         PunchUses int32
35508                                 }))(obj)).DmgGroups) = make([]Group, local400)
35509                                 for local401 := range (*(*(struct {
35510                                         //mt:if _ = %s; false
35511                                         NonNil bool
35512
35513                                         AttackCooldown float32
35514                                         MaxDropLvl     int16
35515
35516                                         //mt:len32
35517                                         GroupCaps []ToolGroupCap
35518
35519                                         //mt:len32
35520                                         DmgGroups []Group
35521
35522                                         //mt:32tou16
35523                                         PunchUses int32
35524                                 }))(obj)).DmgGroups {
35525                                         if err := pcall(func() {
35526                                                 (((*(*(struct {
35527                                                         //mt:if _ = %s; false
35528                                                         NonNil bool
35529
35530                                                         AttackCooldown float32
35531                                                         MaxDropLvl     int16
35532
35533                                                         //mt:len32
35534                                                         GroupCaps []ToolGroupCap
35535
35536                                                         //mt:len32
35537                                                         DmgGroups []Group
35538
35539                                                         //mt:32tou16
35540                                                         PunchUses int32
35541                                                 }))(obj)).DmgGroups)[local401]).Deserialize(r)
35542                                         }); err != nil {
35543                                                 if err == io.EOF {
35544                                                         chk(io.EOF)
35545                                                 }
35546                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
35547                                         }
35548                                 }
35549                                 var local402 uint16
35550                                 {
35551                                         p := &local402
35552                                         *p = read16(r)
35553                                 }
35554                                 (*(*(struct {
35555                                         //mt:if _ = %s; false
35556                                         NonNil bool
35557
35558                                         AttackCooldown float32
35559                                         MaxDropLvl     int16
35560
35561                                         //mt:len32
35562                                         GroupCaps []ToolGroupCap
35563
35564                                         //mt:len32
35565                                         DmgGroups []Group
35566
35567                                         //mt:32tou16
35568                                         PunchUses int32
35569                                 }))(obj)).PunchUses = int32(local402)
35570                         }
35571                 }
35572                 if r.N > 0 {
35573                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
35574                 }
35575         }
35576 }
35577
35578 func (obj *AnimType) Serialize(w io.Writer) {
35579         {
35580                 x := *(*(uint8))(obj)
35581                 write8(w, uint8(x))
35582         }
35583 }
35584
35585 func (obj *AnimType) Deserialize(r io.Reader) {
35586         {
35587                 p := &*(*(uint8))(obj)
35588                 *p = read8(r)
35589         }
35590 }
35591
35592 func (obj *HUDType) Serialize(w io.Writer) {
35593         {
35594                 x := *(*(uint8))(obj)
35595                 write8(w, uint8(x))
35596         }
35597 }
35598
35599 func (obj *HUDType) Deserialize(r io.Reader) {
35600         {
35601                 p := &*(*(uint8))(obj)
35602                 *p = read8(r)
35603         }
35604 }
35605
35606 func (obj *Box) Serialize(w io.Writer) {
35607         for local403 := range *(*([2]Vec))(obj) {
35608                 if err := pcall(func() {
35609                         ((*(*([2]Vec))(obj))[local403]).Serialize(w)
35610                 }); err != nil {
35611                         if err == io.EOF {
35612                                 chk(io.EOF)
35613                         }
35614                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
35615                 }
35616         }
35617 }
35618
35619 func (obj *Box) Deserialize(r io.Reader) {
35620         for local404 := range *(*([2]Vec))(obj) {
35621                 if err := pcall(func() {
35622                         ((*(*([2]Vec))(obj))[local404]).Deserialize(r)
35623                 }); err != nil {
35624                         if err == io.EOF {
35625                                 chk(io.EOF)
35626                         }
35627                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
35628                 }
35629         }
35630 }
35631
35632 func (obj *TileFlags) Serialize(w io.Writer) {
35633         {
35634                 x := *(*(uint16))(obj)
35635                 write16(w, uint16(x))
35636         }
35637 }
35638
35639 func (obj *TileFlags) Deserialize(r io.Reader) {
35640         {
35641                 p := &*(*(uint16))(obj)
35642                 *p = read16(r)
35643         }
35644 }
35645
35646 func (obj *AlignType) Serialize(w io.Writer) {
35647         {
35648                 x := *(*(uint8))(obj)
35649                 write8(w, uint8(x))
35650         }
35651 }
35652
35653 func (obj *AlignType) Deserialize(r io.Reader) {
35654         {
35655                 p := &*(*(uint8))(obj)
35656                 *p = read8(r)
35657         }
35658 }
35659
35660 func (obj *NodeBoxType) Serialize(w io.Writer) {
35661         {
35662                 x := *(*(uint8))(obj)
35663                 write8(w, uint8(x))
35664         }
35665 }
35666
35667 func (obj *NodeBoxType) Deserialize(r io.Reader) {
35668         {
35669                 p := &*(*(uint8))(obj)
35670                 *p = read8(r)
35671         }
35672 }
35673
35674 func (obj *DirBoxes) Serialize(w io.Writer) {
35675         if len(((*(*(struct {
35676                 Top, Bot                 []Box
35677                 Front, Left, Back, Right []Box
35678         }))(obj)).Top)) > math.MaxUint16 {
35679                 chk(ErrTooLong)
35680         }
35681         {
35682                 x := uint16(len(((*(*(struct {
35683                         Top, Bot                 []Box
35684                         Front, Left, Back, Right []Box
35685                 }))(obj)).Top)))
35686                 write16(w, uint16(x))
35687         }
35688         for local405 := range (*(*(struct {
35689                 Top, Bot                 []Box
35690                 Front, Left, Back, Right []Box
35691         }))(obj)).Top {
35692                 if err := pcall(func() {
35693                         (((*(*(struct {
35694                                 Top, Bot                 []Box
35695                                 Front, Left, Back, Right []Box
35696                         }))(obj)).Top)[local405]).Serialize(w)
35697                 }); err != nil {
35698                         if err == io.EOF {
35699                                 chk(io.EOF)
35700                         }
35701                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35702                 }
35703         }
35704         if len(((*(*(struct {
35705                 Top, Bot                 []Box
35706                 Front, Left, Back, Right []Box
35707         }))(obj)).Bot)) > math.MaxUint16 {
35708                 chk(ErrTooLong)
35709         }
35710         {
35711                 x := uint16(len(((*(*(struct {
35712                         Top, Bot                 []Box
35713                         Front, Left, Back, Right []Box
35714                 }))(obj)).Bot)))
35715                 write16(w, uint16(x))
35716         }
35717         for local406 := range (*(*(struct {
35718                 Top, Bot                 []Box
35719                 Front, Left, Back, Right []Box
35720         }))(obj)).Bot {
35721                 if err := pcall(func() {
35722                         (((*(*(struct {
35723                                 Top, Bot                 []Box
35724                                 Front, Left, Back, Right []Box
35725                         }))(obj)).Bot)[local406]).Serialize(w)
35726                 }); err != nil {
35727                         if err == io.EOF {
35728                                 chk(io.EOF)
35729                         }
35730                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35731                 }
35732         }
35733         if len(((*(*(struct {
35734                 Top, Bot                 []Box
35735                 Front, Left, Back, Right []Box
35736         }))(obj)).Front)) > math.MaxUint16 {
35737                 chk(ErrTooLong)
35738         }
35739         {
35740                 x := uint16(len(((*(*(struct {
35741                         Top, Bot                 []Box
35742                         Front, Left, Back, Right []Box
35743                 }))(obj)).Front)))
35744                 write16(w, uint16(x))
35745         }
35746         for local407 := range (*(*(struct {
35747                 Top, Bot                 []Box
35748                 Front, Left, Back, Right []Box
35749         }))(obj)).Front {
35750                 if err := pcall(func() {
35751                         (((*(*(struct {
35752                                 Top, Bot                 []Box
35753                                 Front, Left, Back, Right []Box
35754                         }))(obj)).Front)[local407]).Serialize(w)
35755                 }); err != nil {
35756                         if err == io.EOF {
35757                                 chk(io.EOF)
35758                         }
35759                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35760                 }
35761         }
35762         if len(((*(*(struct {
35763                 Top, Bot                 []Box
35764                 Front, Left, Back, Right []Box
35765         }))(obj)).Left)) > math.MaxUint16 {
35766                 chk(ErrTooLong)
35767         }
35768         {
35769                 x := uint16(len(((*(*(struct {
35770                         Top, Bot                 []Box
35771                         Front, Left, Back, Right []Box
35772                 }))(obj)).Left)))
35773                 write16(w, uint16(x))
35774         }
35775         for local408 := range (*(*(struct {
35776                 Top, Bot                 []Box
35777                 Front, Left, Back, Right []Box
35778         }))(obj)).Left {
35779                 if err := pcall(func() {
35780                         (((*(*(struct {
35781                                 Top, Bot                 []Box
35782                                 Front, Left, Back, Right []Box
35783                         }))(obj)).Left)[local408]).Serialize(w)
35784                 }); err != nil {
35785                         if err == io.EOF {
35786                                 chk(io.EOF)
35787                         }
35788                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35789                 }
35790         }
35791         if len(((*(*(struct {
35792                 Top, Bot                 []Box
35793                 Front, Left, Back, Right []Box
35794         }))(obj)).Back)) > math.MaxUint16 {
35795                 chk(ErrTooLong)
35796         }
35797         {
35798                 x := uint16(len(((*(*(struct {
35799                         Top, Bot                 []Box
35800                         Front, Left, Back, Right []Box
35801                 }))(obj)).Back)))
35802                 write16(w, uint16(x))
35803         }
35804         for local409 := range (*(*(struct {
35805                 Top, Bot                 []Box
35806                 Front, Left, Back, Right []Box
35807         }))(obj)).Back {
35808                 if err := pcall(func() {
35809                         (((*(*(struct {
35810                                 Top, Bot                 []Box
35811                                 Front, Left, Back, Right []Box
35812                         }))(obj)).Back)[local409]).Serialize(w)
35813                 }); err != nil {
35814                         if err == io.EOF {
35815                                 chk(io.EOF)
35816                         }
35817                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35818                 }
35819         }
35820         if len(((*(*(struct {
35821                 Top, Bot                 []Box
35822                 Front, Left, Back, Right []Box
35823         }))(obj)).Right)) > math.MaxUint16 {
35824                 chk(ErrTooLong)
35825         }
35826         {
35827                 x := uint16(len(((*(*(struct {
35828                         Top, Bot                 []Box
35829                         Front, Left, Back, Right []Box
35830                 }))(obj)).Right)))
35831                 write16(w, uint16(x))
35832         }
35833         for local410 := range (*(*(struct {
35834                 Top, Bot                 []Box
35835                 Front, Left, Back, Right []Box
35836         }))(obj)).Right {
35837                 if err := pcall(func() {
35838                         (((*(*(struct {
35839                                 Top, Bot                 []Box
35840                                 Front, Left, Back, Right []Box
35841                         }))(obj)).Right)[local410]).Serialize(w)
35842                 }); err != nil {
35843                         if err == io.EOF {
35844                                 chk(io.EOF)
35845                         }
35846                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35847                 }
35848         }
35849 }
35850
35851 func (obj *DirBoxes) Deserialize(r io.Reader) {
35852         var local411 uint16
35853         {
35854                 p := &local411
35855                 *p = read16(r)
35856         }
35857         ((*(*(struct {
35858                 Top, Bot                 []Box
35859                 Front, Left, Back, Right []Box
35860         }))(obj)).Top) = make([]Box, local411)
35861         for local412 := range (*(*(struct {
35862                 Top, Bot                 []Box
35863                 Front, Left, Back, Right []Box
35864         }))(obj)).Top {
35865                 if err := pcall(func() {
35866                         (((*(*(struct {
35867                                 Top, Bot                 []Box
35868                                 Front, Left, Back, Right []Box
35869                         }))(obj)).Top)[local412]).Deserialize(r)
35870                 }); err != nil {
35871                         if err == io.EOF {
35872                                 chk(io.EOF)
35873                         }
35874                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35875                 }
35876         }
35877         var local413 uint16
35878         {
35879                 p := &local413
35880                 *p = read16(r)
35881         }
35882         ((*(*(struct {
35883                 Top, Bot                 []Box
35884                 Front, Left, Back, Right []Box
35885         }))(obj)).Bot) = make([]Box, local413)
35886         for local414 := range (*(*(struct {
35887                 Top, Bot                 []Box
35888                 Front, Left, Back, Right []Box
35889         }))(obj)).Bot {
35890                 if err := pcall(func() {
35891                         (((*(*(struct {
35892                                 Top, Bot                 []Box
35893                                 Front, Left, Back, Right []Box
35894                         }))(obj)).Bot)[local414]).Deserialize(r)
35895                 }); err != nil {
35896                         if err == io.EOF {
35897                                 chk(io.EOF)
35898                         }
35899                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35900                 }
35901         }
35902         var local415 uint16
35903         {
35904                 p := &local415
35905                 *p = read16(r)
35906         }
35907         ((*(*(struct {
35908                 Top, Bot                 []Box
35909                 Front, Left, Back, Right []Box
35910         }))(obj)).Front) = make([]Box, local415)
35911         for local416 := range (*(*(struct {
35912                 Top, Bot                 []Box
35913                 Front, Left, Back, Right []Box
35914         }))(obj)).Front {
35915                 if err := pcall(func() {
35916                         (((*(*(struct {
35917                                 Top, Bot                 []Box
35918                                 Front, Left, Back, Right []Box
35919                         }))(obj)).Front)[local416]).Deserialize(r)
35920                 }); err != nil {
35921                         if err == io.EOF {
35922                                 chk(io.EOF)
35923                         }
35924                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35925                 }
35926         }
35927         var local417 uint16
35928         {
35929                 p := &local417
35930                 *p = read16(r)
35931         }
35932         ((*(*(struct {
35933                 Top, Bot                 []Box
35934                 Front, Left, Back, Right []Box
35935         }))(obj)).Left) = make([]Box, local417)
35936         for local418 := range (*(*(struct {
35937                 Top, Bot                 []Box
35938                 Front, Left, Back, Right []Box
35939         }))(obj)).Left {
35940                 if err := pcall(func() {
35941                         (((*(*(struct {
35942                                 Top, Bot                 []Box
35943                                 Front, Left, Back, Right []Box
35944                         }))(obj)).Left)[local418]).Deserialize(r)
35945                 }); err != nil {
35946                         if err == io.EOF {
35947                                 chk(io.EOF)
35948                         }
35949                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35950                 }
35951         }
35952         var local419 uint16
35953         {
35954                 p := &local419
35955                 *p = read16(r)
35956         }
35957         ((*(*(struct {
35958                 Top, Bot                 []Box
35959                 Front, Left, Back, Right []Box
35960         }))(obj)).Back) = make([]Box, local419)
35961         for local420 := range (*(*(struct {
35962                 Top, Bot                 []Box
35963                 Front, Left, Back, Right []Box
35964         }))(obj)).Back {
35965                 if err := pcall(func() {
35966                         (((*(*(struct {
35967                                 Top, Bot                 []Box
35968                                 Front, Left, Back, Right []Box
35969                         }))(obj)).Back)[local420]).Deserialize(r)
35970                 }); err != nil {
35971                         if err == io.EOF {
35972                                 chk(io.EOF)
35973                         }
35974                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35975                 }
35976         }
35977         var local421 uint16
35978         {
35979                 p := &local421
35980                 *p = read16(r)
35981         }
35982         ((*(*(struct {
35983                 Top, Bot                 []Box
35984                 Front, Left, Back, Right []Box
35985         }))(obj)).Right) = make([]Box, local421)
35986         for local422 := range (*(*(struct {
35987                 Top, Bot                 []Box
35988                 Front, Left, Back, Right []Box
35989         }))(obj)).Right {
35990                 if err := pcall(func() {
35991                         (((*(*(struct {
35992                                 Top, Bot                 []Box
35993                                 Front, Left, Back, Right []Box
35994                         }))(obj)).Right)[local422]).Deserialize(r)
35995                 }); err != nil {
35996                         if err == io.EOF {
35997                                 chk(io.EOF)
35998                         }
35999                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
36000                 }
36001         }
36002 }
36003
36004 func (obj *ToolGroupCap) Serialize(w io.Writer) {
36005         if len(([]byte((*(*(struct {
36006                 Name string
36007
36008                 //mt:32to16
36009                 Uses int32
36010
36011                 MaxLvl int16
36012
36013                 //mt:len32
36014                 Times []DigTime
36015         }))(obj)).Name))) > math.MaxUint16 {
36016                 chk(ErrTooLong)
36017         }
36018         {
36019                 x := uint16(len(([]byte((*(*(struct {
36020                         Name string
36021
36022                         //mt:32to16
36023                         Uses int32
36024
36025                         MaxLvl int16
36026
36027                         //mt:len32
36028                         Times []DigTime
36029                 }))(obj)).Name))))
36030                 write16(w, uint16(x))
36031         }
36032         {
36033                 _, err := w.Write(([]byte((*(*(struct {
36034                         Name string
36035
36036                         //mt:32to16
36037                         Uses int32
36038
36039                         MaxLvl int16
36040
36041                         //mt:len32
36042                         Times []DigTime
36043                 }))(obj)).Name))[:])
36044                 chk(err)
36045         }
36046         {
36047                 x := int16((*(*(struct {
36048                         Name string
36049
36050                         //mt:32to16
36051                         Uses int32
36052
36053                         MaxLvl int16
36054
36055                         //mt:len32
36056                         Times []DigTime
36057                 }))(obj)).Uses)
36058                 write16(w, uint16(x))
36059         }
36060         {
36061                 x := (*(*(struct {
36062                         Name string
36063
36064                         //mt:32to16
36065                         Uses int32
36066
36067                         MaxLvl int16
36068
36069                         //mt:len32
36070                         Times []DigTime
36071                 }))(obj)).MaxLvl
36072                 write16(w, uint16(x))
36073         }
36074         if len(((*(*(struct {
36075                 Name string
36076
36077                 //mt:32to16
36078                 Uses int32
36079
36080                 MaxLvl int16
36081
36082                 //mt:len32
36083                 Times []DigTime
36084         }))(obj)).Times)) > math.MaxUint32 {
36085                 chk(ErrTooLong)
36086         }
36087         {
36088                 x := uint32(len(((*(*(struct {
36089                         Name string
36090
36091                         //mt:32to16
36092                         Uses int32
36093
36094                         MaxLvl int16
36095
36096                         //mt:len32
36097                         Times []DigTime
36098                 }))(obj)).Times)))
36099                 write32(w, uint32(x))
36100         }
36101         for local423 := range (*(*(struct {
36102                 Name string
36103
36104                 //mt:32to16
36105                 Uses int32
36106
36107                 MaxLvl int16
36108
36109                 //mt:len32
36110                 Times []DigTime
36111         }))(obj)).Times {
36112                 if err := pcall(func() {
36113                         (((*(*(struct {
36114                                 Name string
36115
36116                                 //mt:32to16
36117                                 Uses int32
36118
36119                                 MaxLvl int16
36120
36121                                 //mt:len32
36122                                 Times []DigTime
36123                         }))(obj)).Times)[local423]).Serialize(w)
36124                 }); err != nil {
36125                         if err == io.EOF {
36126                                 chk(io.EOF)
36127                         }
36128                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
36129                 }
36130         }
36131 }
36132
36133 func (obj *ToolGroupCap) Deserialize(r io.Reader) {
36134         var local424 []uint8
36135         var local425 uint16
36136         {
36137                 p := &local425
36138                 *p = read16(r)
36139         }
36140         (local424) = make([]uint8, local425)
36141         {
36142                 _, err := io.ReadFull(r, (local424)[:])
36143                 chk(err)
36144         }
36145         ((*(*(struct {
36146                 Name string
36147
36148                 //mt:32to16
36149                 Uses int32
36150
36151                 MaxLvl int16
36152
36153                 //mt:len32
36154                 Times []DigTime
36155         }))(obj)).Name) = string(local424)
36156         var local426 int16
36157         {
36158                 p := &local426
36159                 *p = int16(read16(r))
36160         }
36161         (*(*(struct {
36162                 Name string
36163
36164                 //mt:32to16
36165                 Uses int32
36166
36167                 MaxLvl int16
36168
36169                 //mt:len32
36170                 Times []DigTime
36171         }))(obj)).Uses = int32(local426)
36172         {
36173                 p := &(*(*(struct {
36174                         Name string
36175
36176                         //mt:32to16
36177                         Uses int32
36178
36179                         MaxLvl int16
36180
36181                         //mt:len32
36182                         Times []DigTime
36183                 }))(obj)).MaxLvl
36184                 *p = int16(read16(r))
36185         }
36186         var local427 uint32
36187         {
36188                 p := &local427
36189                 *p = read32(r)
36190         }
36191         ((*(*(struct {
36192                 Name string
36193
36194                 //mt:32to16
36195                 Uses int32
36196
36197                 MaxLvl int16
36198
36199                 //mt:len32
36200                 Times []DigTime
36201         }))(obj)).Times) = make([]DigTime, local427)
36202         for local428 := range (*(*(struct {
36203                 Name string
36204
36205                 //mt:32to16
36206                 Uses int32
36207
36208                 MaxLvl int16
36209
36210                 //mt:len32
36211                 Times []DigTime
36212         }))(obj)).Times {
36213                 if err := pcall(func() {
36214                         (((*(*(struct {
36215                                 Name string
36216
36217                                 //mt:32to16
36218                                 Uses int32
36219
36220                                 MaxLvl int16
36221
36222                                 //mt:len32
36223                                 Times []DigTime
36224                         }))(obj)).Times)[local428]).Deserialize(r)
36225                 }); err != nil {
36226                         if err == io.EOF {
36227                                 chk(io.EOF)
36228                         }
36229                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
36230                 }
36231         }
36232 }
36233
36234 func (obj *DigTime) Serialize(w io.Writer) {
36235         {
36236                 x := (*(*(struct {
36237                         Rating int16
36238                         Time   float32
36239                 }))(obj)).Rating
36240                 write16(w, uint16(x))
36241         }
36242         {
36243                 x := (*(*(struct {
36244                         Rating int16
36245                         Time   float32
36246                 }))(obj)).Time
36247                 write32(w, math.Float32bits(x))
36248         }
36249 }
36250
36251 func (obj *DigTime) Deserialize(r io.Reader) {
36252         {
36253                 p := &(*(*(struct {
36254                         Rating int16
36255                         Time   float32
36256                 }))(obj)).Rating
36257                 *p = int16(read16(r))
36258         }
36259         {
36260                 p := &(*(*(struct {
36261                         Rating int16
36262                         Time   float32
36263                 }))(obj)).Time
36264                 *p = math.Float32frombits(read32(r))
36265         }
36266 }