serialize.go

   1 // Code generated by mkserialize.sh; DO NOT EDIT.
   2
   3 package mt
   4
   5 import (
   6         "bytes"
   7         "compress/zlib"
   8         "errors"
   9         "fmt"
  10         "image/color"
  11         "io"
  12         "math"
  13         "sort"
  14         "unicode/utf16"
  15
  16         "github.com/klauspost/compress/zstd"
  17 )
  18
  19 func write8(w io.Writer, x uint8) {
  20         _, err := w.Write([]byte{x})
  21         chk(err)
  22 }
  23 func write16(w io.Writer, x uint16) {
  24         buf := make([]byte, 2)
  25         be.PutUint16(buf, x)
  26         _, err := w.Write(buf)
  27         chk(err)
  28 }
  29 func write32(w io.Writer, x uint32) {
  30         buf := make([]byte, 4)
  31         be.PutUint32(buf, x)
  32         _, err := w.Write(buf)
  33         chk(err)
  34 }
  35 func write64(w io.Writer, x uint64) {
  36         buf := make([]byte, 8)
  37         be.PutUint64(buf, x)
  38         _, err := w.Write(buf)
  39         chk(err)
  40 }
  41 func readBuf(r io.Reader, n int) []byte {
  42         buf := make([]byte, n)
  43         _, err := io.ReadFull(r, buf)
  44         chk(err)
  45         return buf
  46 }
  47 func read8(r io.Reader) uint8   { return readBuf(r, 1)[0] }
  48 func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  49 func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  50 func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  51
  52 func (obj *ToSrvNil) serialize(w io.Writer) {
  53 }
  54
  55 func (obj *ToSrvNil) deserialize(r io.Reader) {
  56 }
  57
  58 func (obj *ToSrvInit) serialize(w io.Writer) {
  59         {
  60                 x := (*(*(struct {
  61                         SerializeVer             uint8
  62                         SupportedCompression     CompressionModes
  63                         MinProtoVer, MaxProtoVer uint16
  64                         PlayerName               string
  65
  66                         //mt:opt
  67                         SendFullItemMeta bool
  68                 }))(obj)).SerializeVer
  69                 write8(w, uint8(x))
  70         }
  71         if err := pcall(func() {
  72                 ((*(*(struct {
  73                         SerializeVer             uint8
  74                         SupportedCompression     CompressionModes
  75                         MinProtoVer, MaxProtoVer uint16
  76                         PlayerName               string
  77
  78                         //mt:opt
  79                         SendFullItemMeta bool
  80                 }))(obj)).SupportedCompression).serialize(w)
  81         }); err != nil {
  82                 if err == io.EOF {
  83                         chk(io.EOF)
  84                 }
  85                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CompressionModes", err))
  86         }
  87         {
  88                 x := (*(*(struct {
  89                         SerializeVer             uint8
  90                         SupportedCompression     CompressionModes
  91                         MinProtoVer, MaxProtoVer uint16
  92                         PlayerName               string
  93
  94                         //mt:opt
  95                         SendFullItemMeta bool
  96                 }))(obj)).MinProtoVer
  97                 write16(w, uint16(x))
  98         }
  99         {
 100                 x := (*(*(struct {
 101                         SerializeVer             uint8
 102                         SupportedCompression     CompressionModes
 103                         MinProtoVer, MaxProtoVer uint16
 104                         PlayerName               string
 105
 106                         //mt:opt
 107                         SendFullItemMeta bool
 108                 }))(obj)).MaxProtoVer
 109                 write16(w, uint16(x))
 110         }
 111         if len(([]byte((*(*(struct {
 112                 SerializeVer             uint8
 113                 SupportedCompression     CompressionModes
 114                 MinProtoVer, MaxProtoVer uint16
 115                 PlayerName               string
 116
 117                 //mt:opt
 118                 SendFullItemMeta bool
 119         }))(obj)).PlayerName))) > math.MaxUint16 {
 120                 chk(ErrTooLong)
 121         }
 122         {
 123                 x := uint16(len(([]byte((*(*(struct {
 124                         SerializeVer             uint8
 125                         SupportedCompression     CompressionModes
 126                         MinProtoVer, MaxProtoVer uint16
 127                         PlayerName               string
 128
 129                         //mt:opt
 130                         SendFullItemMeta bool
 131                 }))(obj)).PlayerName))))
 132                 write16(w, uint16(x))
 133         }
 134         {
 135                 _, err := w.Write(([]byte((*(*(struct {
 136                         SerializeVer             uint8
 137                         SupportedCompression     CompressionModes
 138                         MinProtoVer, MaxProtoVer uint16
 139                         PlayerName               string
 140
 141                         //mt:opt
 142                         SendFullItemMeta bool
 143                 }))(obj)).PlayerName))[:])
 144                 chk(err)
 145         }
 146         if err := pcall(func() {
 147                 {
 148                         x := (*(*(struct {
 149                                 SerializeVer             uint8
 150                                 SupportedCompression     CompressionModes
 151                                 MinProtoVer, MaxProtoVer uint16
 152                                 PlayerName               string
 153
 154                                 //mt:opt
 155                                 SendFullItemMeta bool
 156                         }))(obj)).SendFullItemMeta
 157                         if x {
 158                                 write8(w, 1)
 159                         } else {
 160                                 write8(w, 0)
 161                         }
 162                 }
 163         }); err != nil && err != io.EOF {
 164                 chk(err)
 165         }
 166 }
 167
 168 func (obj *ToSrvInit) deserialize(r io.Reader) {
 169         {
 170                 p := &(*(*(struct {
 171                         SerializeVer             uint8
 172                         SupportedCompression     CompressionModes
 173                         MinProtoVer, MaxProtoVer uint16
 174                         PlayerName               string
 175
 176                         //mt:opt
 177                         SendFullItemMeta bool
 178                 }))(obj)).SerializeVer
 179                 *p = read8(r)
 180         }
 181         if err := pcall(func() {
 182                 ((*(*(struct {
 183                         SerializeVer             uint8
 184                         SupportedCompression     CompressionModes
 185                         MinProtoVer, MaxProtoVer uint16
 186                         PlayerName               string
 187
 188                         //mt:opt
 189                         SendFullItemMeta bool
 190                 }))(obj)).SupportedCompression).deserialize(r)
 191         }); err != nil {
 192                 if err == io.EOF {
 193                         chk(io.EOF)
 194                 }
 195                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CompressionModes", err))
 196         }
 197         {
 198                 p := &(*(*(struct {
 199                         SerializeVer             uint8
 200                         SupportedCompression     CompressionModes
 201                         MinProtoVer, MaxProtoVer uint16
 202                         PlayerName               string
 203
 204                         //mt:opt
 205                         SendFullItemMeta bool
 206                 }))(obj)).MinProtoVer
 207                 *p = read16(r)
 208         }
 209         {
 210                 p := &(*(*(struct {
 211                         SerializeVer             uint8
 212                         SupportedCompression     CompressionModes
 213                         MinProtoVer, MaxProtoVer uint16
 214                         PlayerName               string
 215
 216                         //mt:opt
 217                         SendFullItemMeta bool
 218                 }))(obj)).MaxProtoVer
 219                 *p = read16(r)
 220         }
 221         var local1 []uint8
 222         var local2 uint16
 223         {
 224                 p := &local2
 225                 *p = read16(r)
 226         }
 227         (local1) = make([]uint8, local2)
 228         {
 229                 _, err := io.ReadFull(r, (local1)[:])
 230                 chk(err)
 231         }
 232         ((*(*(struct {
 233                 SerializeVer             uint8
 234                 SupportedCompression     CompressionModes
 235                 MinProtoVer, MaxProtoVer uint16
 236                 PlayerName               string
 237
 238                 //mt:opt
 239                 SendFullItemMeta bool
 240         }))(obj)).PlayerName) = string(local1)
 241         if err := pcall(func() {
 242                 {
 243                         p := &(*(*(struct {
 244                                 SerializeVer             uint8
 245                                 SupportedCompression     CompressionModes
 246                                 MinProtoVer, MaxProtoVer uint16
 247                                 PlayerName               string
 248
 249                                 //mt:opt
 250                                 SendFullItemMeta bool
 251                         }))(obj)).SendFullItemMeta
 252                         switch n := read8(r); n {
 253                         case 0:
 254                                 *p = false
 255                         case 1:
 256                                 *p = true
 257                         default:
 258                                 chk(fmt.Errorf("invalid bool: %d", n))
 259                         }
 260                 }
 261         }); err != nil && err != io.EOF {
 262                 chk(err)
 263         }
 264 }
 265
 266 func (obj *ToSrvInit2) serialize(w io.Writer) {
 267         if len(([]byte((*(*(struct {
 268                 Lang string
 269         }))(obj)).Lang))) > math.MaxUint16 {
 270                 chk(ErrTooLong)
 271         }
 272         {
 273                 x := uint16(len(([]byte((*(*(struct {
 274                         Lang string
 275                 }))(obj)).Lang))))
 276                 write16(w, uint16(x))
 277         }
 278         {
 279                 _, err := w.Write(([]byte((*(*(struct {
 280                         Lang string
 281                 }))(obj)).Lang))[:])
 282                 chk(err)
 283         }
 284 }
 285
 286 func (obj *ToSrvInit2) deserialize(r io.Reader) {
 287         var local3 []uint8
 288         var local4 uint16
 289         {
 290                 p := &local4
 291                 *p = read16(r)
 292         }
 293         (local3) = make([]uint8, local4)
 294         {
 295                 _, err := io.ReadFull(r, (local3)[:])
 296                 chk(err)
 297         }
 298         ((*(*(struct {
 299                 Lang string
 300         }))(obj)).Lang) = string(local3)
 301 }
 302
 303 func (obj *ToSrvJoinModChan) serialize(w io.Writer) {
 304         if len(([]byte((*(*(struct {
 305                 Channel string
 306         }))(obj)).Channel))) > math.MaxUint16 {
 307                 chk(ErrTooLong)
 308         }
 309         {
 310                 x := uint16(len(([]byte((*(*(struct {
 311                         Channel string
 312                 }))(obj)).Channel))))
 313                 write16(w, uint16(x))
 314         }
 315         {
 316                 _, err := w.Write(([]byte((*(*(struct {
 317                         Channel string
 318                 }))(obj)).Channel))[:])
 319                 chk(err)
 320         }
 321 }
 322
 323 func (obj *ToSrvJoinModChan) deserialize(r io.Reader) {
 324         var local5 []uint8
 325         var local6 uint16
 326         {
 327                 p := &local6
 328                 *p = read16(r)
 329         }
 330         (local5) = make([]uint8, local6)
 331         {
 332                 _, err := io.ReadFull(r, (local5)[:])
 333                 chk(err)
 334         }
 335         ((*(*(struct {
 336                 Channel string
 337         }))(obj)).Channel) = string(local5)
 338 }
 339
 340 func (obj *ToSrvLeaveModChan) serialize(w io.Writer) {
 341         if len(([]byte((*(*(struct {
 342                 Channel string
 343         }))(obj)).Channel))) > math.MaxUint16 {
 344                 chk(ErrTooLong)
 345         }
 346         {
 347                 x := uint16(len(([]byte((*(*(struct {
 348                         Channel string
 349                 }))(obj)).Channel))))
 350                 write16(w, uint16(x))
 351         }
 352         {
 353                 _, err := w.Write(([]byte((*(*(struct {
 354                         Channel string
 355                 }))(obj)).Channel))[:])
 356                 chk(err)
 357         }
 358 }
 359
 360 func (obj *ToSrvLeaveModChan) deserialize(r io.Reader) {
 361         var local7 []uint8
 362         var local8 uint16
 363         {
 364                 p := &local8
 365                 *p = read16(r)
 366         }
 367         (local7) = make([]uint8, local8)
 368         {
 369                 _, err := io.ReadFull(r, (local7)[:])
 370                 chk(err)
 371         }
 372         ((*(*(struct {
 373                 Channel string
 374         }))(obj)).Channel) = string(local7)
 375 }
 376
 377 func (obj *ToSrvMsgModChan) serialize(w io.Writer) {
 378         if len(([]byte((*(*(struct {
 379                 Channel string
 380                 Msg     string
 381         }))(obj)).Channel))) > math.MaxUint16 {
 382                 chk(ErrTooLong)
 383         }
 384         {
 385                 x := uint16(len(([]byte((*(*(struct {
 386                         Channel string
 387                         Msg     string
 388                 }))(obj)).Channel))))
 389                 write16(w, uint16(x))
 390         }
 391         {
 392                 _, err := w.Write(([]byte((*(*(struct {
 393                         Channel string
 394                         Msg     string
 395                 }))(obj)).Channel))[:])
 396                 chk(err)
 397         }
 398         if len(([]byte((*(*(struct {
 399                 Channel string
 400                 Msg     string
 401         }))(obj)).Msg))) > math.MaxUint16 {
 402                 chk(ErrTooLong)
 403         }
 404         {
 405                 x := uint16(len(([]byte((*(*(struct {
 406                         Channel string
 407                         Msg     string
 408                 }))(obj)).Msg))))
 409                 write16(w, uint16(x))
 410         }
 411         {
 412                 _, err := w.Write(([]byte((*(*(struct {
 413                         Channel string
 414                         Msg     string
 415                 }))(obj)).Msg))[:])
 416                 chk(err)
 417         }
 418 }
 419
 420 func (obj *ToSrvMsgModChan) deserialize(r io.Reader) {
 421         var local9 []uint8
 422         var local10 uint16
 423         {
 424                 p := &local10
 425                 *p = read16(r)
 426         }
 427         (local9) = make([]uint8, local10)
 428         {
 429                 _, err := io.ReadFull(r, (local9)[:])
 430                 chk(err)
 431         }
 432         ((*(*(struct {
 433                 Channel string
 434                 Msg     string
 435         }))(obj)).Channel) = string(local9)
 436         var local11 []uint8
 437         var local12 uint16
 438         {
 439                 p := &local12
 440                 *p = read16(r)
 441         }
 442         (local11) = make([]uint8, local12)
 443         {
 444                 _, err := io.ReadFull(r, (local11)[:])
 445                 chk(err)
 446         }
 447         ((*(*(struct {
 448                 Channel string
 449                 Msg     string
 450         }))(obj)).Msg) = string(local11)
 451 }
 452
 453 func (obj *ToSrvPlayerPos) serialize(w io.Writer) {
 454         if err := pcall(func() {
 455                 ((*(*(struct {
 456                         Pos PlayerPos
 457                 }))(obj)).Pos).serialize(w)
 458         }); err != nil {
 459                 if err == io.EOF {
 460                         chk(io.EOF)
 461                 }
 462                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerPos", err))
 463         }
 464 }
 465
 466 func (obj *ToSrvPlayerPos) deserialize(r io.Reader) {
 467         if err := pcall(func() {
 468                 ((*(*(struct {
 469                         Pos PlayerPos
 470                 }))(obj)).Pos).deserialize(r)
 471         }); err != nil {
 472                 if err == io.EOF {
 473                         chk(io.EOF)
 474                 }
 475                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerPos", err))
 476         }
 477 }
 478
 479 func (obj *ToSrvGotBlks) serialize(w io.Writer) {
 480         if len(((*(*(struct {
 481                 //mt:len8
 482                 Blks [][3]int16
 483         }))(obj)).Blks)) > math.MaxUint8 {
 484                 chk(ErrTooLong)
 485         }
 486         {
 487                 x := uint8(len(((*(*(struct {
 488                         //mt:len8
 489                         Blks [][3]int16
 490                 }))(obj)).Blks)))
 491                 write8(w, uint8(x))
 492         }
 493         for local13 := range (*(*(struct {
 494                 //mt:len8
 495                 Blks [][3]int16
 496         }))(obj)).Blks {
 497                 for local14 := range ((*(*(struct {
 498                         //mt:len8
 499                         Blks [][3]int16
 500                 }))(obj)).Blks)[local13] {
 501                         {
 502                                 x := (((*(*(struct {
 503                                         //mt:len8
 504                                         Blks [][3]int16
 505                                 }))(obj)).Blks)[local13])[local14]
 506                                 write16(w, uint16(x))
 507                         }
 508                 }
 509         }
 510 }
 511
 512 func (obj *ToSrvGotBlks) deserialize(r io.Reader) {
 513         var local15 uint8
 514         {
 515                 p := &local15
 516                 *p = read8(r)
 517         }
 518         ((*(*(struct {
 519                 //mt:len8
 520                 Blks [][3]int16
 521         }))(obj)).Blks) = make([][3]int16, local15)
 522         for local16 := range (*(*(struct {
 523                 //mt:len8
 524                 Blks [][3]int16
 525         }))(obj)).Blks {
 526                 for local17 := range ((*(*(struct {
 527                         //mt:len8
 528                         Blks [][3]int16
 529                 }))(obj)).Blks)[local16] {
 530                         {
 531                                 p := &(((*(*(struct {
 532                                         //mt:len8
 533                                         Blks [][3]int16
 534                                 }))(obj)).Blks)[local16])[local17]
 535                                 *p = int16(read16(r))
 536                         }
 537                 }
 538         }
 539 }
 540
 541 func (obj *ToSrvDeletedBlks) serialize(w io.Writer) {
 542         if len(((*(*(struct {
 543                 //mt:len8
 544                 Blks [][3]int16
 545         }))(obj)).Blks)) > math.MaxUint8 {
 546                 chk(ErrTooLong)
 547         }
 548         {
 549                 x := uint8(len(((*(*(struct {
 550                         //mt:len8
 551                         Blks [][3]int16
 552                 }))(obj)).Blks)))
 553                 write8(w, uint8(x))
 554         }
 555         for local18 := range (*(*(struct {
 556                 //mt:len8
 557                 Blks [][3]int16
 558         }))(obj)).Blks {
 559                 for local19 := range ((*(*(struct {
 560                         //mt:len8
 561                         Blks [][3]int16
 562                 }))(obj)).Blks)[local18] {
 563                         {
 564                                 x := (((*(*(struct {
 565                                         //mt:len8
 566                                         Blks [][3]int16
 567                                 }))(obj)).Blks)[local18])[local19]
 568                                 write16(w, uint16(x))
 569                         }
 570                 }
 571         }
 572 }
 573
 574 func (obj *ToSrvDeletedBlks) deserialize(r io.Reader) {
 575         var local20 uint8
 576         {
 577                 p := &local20
 578                 *p = read8(r)
 579         }
 580         ((*(*(struct {
 581                 //mt:len8
 582                 Blks [][3]int16
 583         }))(obj)).Blks) = make([][3]int16, local20)
 584         for local21 := range (*(*(struct {
 585                 //mt:len8
 586                 Blks [][3]int16
 587         }))(obj)).Blks {
 588                 for local22 := range ((*(*(struct {
 589                         //mt:len8
 590                         Blks [][3]int16
 591                 }))(obj)).Blks)[local21] {
 592                         {
 593                                 p := &(((*(*(struct {
 594                                         //mt:len8
 595                                         Blks [][3]int16
 596                                 }))(obj)).Blks)[local21])[local22]
 597                                 *p = int16(read16(r))
 598                         }
 599                 }
 600         }
 601 }
 602
 603 func (obj *ToSrvInvAction) serialize(w io.Writer) {
 604         {
 605                 _, err := w.Write(([]byte((*(*(struct {
 606                         //mt:raw
 607                         Action string
 608                 }))(obj)).Action))[:])
 609                 chk(err)
 610         }
 611 }
 612
 613 func (obj *ToSrvInvAction) deserialize(r io.Reader) {
 614         var local23 []uint8
 615         {
 616                 var err error
 617                 (local23), err = io.ReadAll(r)
 618                 chk(err)
 619         }
 620         ((*(*(struct {
 621                 //mt:raw
 622                 Action string
 623         }))(obj)).Action) = string(local23)
 624 }
 625
 626 func (obj *ToSrvChatMsg) serialize(w io.Writer) {
 627         local24 := utf16.Encode([]rune((*(*(struct {
 628                 //mt:utf16
 629                 Msg string
 630         }))(obj)).Msg))
 631         if len((local24)) > math.MaxUint16 {
 632                 chk(ErrTooLong)
 633         }
 634         {
 635                 x := uint16(len((local24)))
 636                 write16(w, uint16(x))
 637         }
 638         for local25 := range local24 {
 639                 {
 640                         x := (local24)[local25]
 641                         write16(w, uint16(x))
 642                 }
 643         }
 644 }
 645
 646 func (obj *ToSrvChatMsg) deserialize(r io.Reader) {
 647         var local26 []uint16
 648         var local27 uint16
 649         {
 650                 p := &local27
 651                 *p = read16(r)
 652         }
 653         (local26) = make([]uint16, local27)
 654         for local28 := range local26 {
 655                 {
 656                         p := &(local26)[local28]
 657                         *p = read16(r)
 658                 }
 659         }
 660         (*(*(struct {
 661                 //mt:utf16
 662                 Msg string
 663         }))(obj)).Msg = string(utf16.Decode(local26))
 664 }
 665
 666 func (obj *ToSrvFallDmg) serialize(w io.Writer) {
 667         {
 668                 x := (*(*(struct {
 669                         Amount uint16
 670                 }))(obj)).Amount
 671                 write16(w, uint16(x))
 672         }
 673 }
 674
 675 func (obj *ToSrvFallDmg) deserialize(r io.Reader) {
 676         {
 677                 p := &(*(*(struct {
 678                         Amount uint16
 679                 }))(obj)).Amount
 680                 *p = read16(r)
 681         }
 682 }
 683
 684 func (obj *ToSrvSelectItem) serialize(w io.Writer) {
 685         {
 686                 x := (*(*(struct {
 687                         Slot uint16
 688                 }))(obj)).Slot
 689                 write16(w, uint16(x))
 690         }
 691 }
 692
 693 func (obj *ToSrvSelectItem) deserialize(r io.Reader) {
 694         {
 695                 p := &(*(*(struct {
 696                         Slot uint16
 697                 }))(obj)).Slot
 698                 *p = read16(r)
 699         }
 700 }
 701
 702 func (obj *ToSrvRespawn) serialize(w io.Writer) {
 703 }
 704
 705 func (obj *ToSrvRespawn) deserialize(r io.Reader) {
 706 }
 707
 708 func (obj *ToSrvInteract) serialize(w io.Writer) {
 709         if err := pcall(func() {
 710                 ((*(*(struct {
 711                         Action   Interaction
 712                         ItemSlot uint16
 713                         //mt:lenhdr 32
 714                         Pointed PointedThing
 715                         //mt:end
 716                         Pos PlayerPos
 717                 }))(obj)).Action).serialize(w)
 718         }); err != nil {
 719                 if err == io.EOF {
 720                         chk(io.EOF)
 721                 }
 722                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Interaction", err))
 723         }
 724         {
 725                 x := (*(*(struct {
 726                         Action   Interaction
 727                         ItemSlot uint16
 728                         //mt:lenhdr 32
 729                         Pointed PointedThing
 730                         //mt:end
 731                         Pos PlayerPos
 732                 }))(obj)).ItemSlot
 733                 write16(w, uint16(x))
 734         }
 735         {
 736                 ow := w
 737                 w := new(bytes.Buffer)
 738                 {
 739                         x := (*(*(struct {
 740                                 Action   Interaction
 741                                 ItemSlot uint16
 742                                 //mt:lenhdr 32
 743                                 Pointed PointedThing
 744                                 //mt:end
 745                                 Pos PlayerPos
 746                         }))(obj)).Pointed
 747                         chk(writePointedThing(w, x))
 748                 }
 749                 {
 750                         buf := w
 751                         w := ow
 752                         if len((buf.Bytes())) > math.MaxUint32 {
 753                                 chk(ErrTooLong)
 754                         }
 755                         {
 756                                 x := uint32(len((buf.Bytes())))
 757                                 write32(w, uint32(x))
 758                         }
 759                         {
 760                                 _, err := w.Write((buf.Bytes())[:])
 761                                 chk(err)
 762                         }
 763                 }
 764         }
 765         if err := pcall(func() {
 766                 ((*(*(struct {
 767                         Action   Interaction
 768                         ItemSlot uint16
 769                         //mt:lenhdr 32
 770                         Pointed PointedThing
 771                         //mt:end
 772                         Pos PlayerPos
 773                 }))(obj)).Pos).serialize(w)
 774         }); err != nil {
 775                 if err == io.EOF {
 776                         chk(io.EOF)
 777                 }
 778                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerPos", err))
 779         }
 780 }
 781
 782 func (obj *ToSrvInteract) deserialize(r io.Reader) {
 783         if err := pcall(func() {
 784                 ((*(*(struct {
 785                         Action   Interaction
 786                         ItemSlot uint16
 787                         //mt:lenhdr 32
 788                         Pointed PointedThing
 789                         //mt:end
 790                         Pos PlayerPos
 791                 }))(obj)).Action).deserialize(r)
 792         }); err != nil {
 793                 if err == io.EOF {
 794                         chk(io.EOF)
 795                 }
 796                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Interaction", err))
 797         }
 798         {
 799                 p := &(*(*(struct {
 800                         Action   Interaction
 801                         ItemSlot uint16
 802                         //mt:lenhdr 32
 803                         Pointed PointedThing
 804                         //mt:end
 805                         Pos PlayerPos
 806                 }))(obj)).ItemSlot
 807                 *p = read16(r)
 808         }
 809         {
 810                 var n uint32
 811                 {
 812                         p := &n
 813                         *p = read32(r)
 814                 }
 815                 r := &io.LimitedReader{R: r, N: int64(n)}
 816                 {
 817                         p := &(*(*(struct {
 818                                 Action   Interaction
 819                                 ItemSlot uint16
 820                                 //mt:lenhdr 32
 821                                 Pointed PointedThing
 822                                 //mt:end
 823                                 Pos PlayerPos
 824                         }))(obj)).Pointed
 825                         {
 826                                 var err error
 827                                 *p, err = readPointedThing(r)
 828                                 chk(err)
 829                         }
 830                 }
 831                 if r.N > 0 {
 832                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 833                 }
 834         }
 835         if err := pcall(func() {
 836                 ((*(*(struct {
 837                         Action   Interaction
 838                         ItemSlot uint16
 839                         //mt:lenhdr 32
 840                         Pointed PointedThing
 841                         //mt:end
 842                         Pos PlayerPos
 843                 }))(obj)).Pos).deserialize(r)
 844         }); err != nil {
 845                 if err == io.EOF {
 846                         chk(io.EOF)
 847                 }
 848                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerPos", err))
 849         }
 850 }
 851
 852 func (obj *ToSrvRemovedSounds) serialize(w io.Writer) {
 853         if len(((*(*(struct {
 854                 IDs []SoundID
 855         }))(obj)).IDs)) > math.MaxUint16 {
 856                 chk(ErrTooLong)
 857         }
 858         {
 859                 x := uint16(len(((*(*(struct {
 860                         IDs []SoundID
 861                 }))(obj)).IDs)))
 862                 write16(w, uint16(x))
 863         }
 864         for local29 := range (*(*(struct {
 865                 IDs []SoundID
 866         }))(obj)).IDs {
 867                 if err := pcall(func() {
 868                         (((*(*(struct {
 869                                 IDs []SoundID
 870                         }))(obj)).IDs)[local29]).serialize(w)
 871                 }); err != nil {
 872                         if err == io.EOF {
 873                                 chk(io.EOF)
 874                         }
 875                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
 876                 }
 877         }
 878 }
 879
 880 func (obj *ToSrvRemovedSounds) deserialize(r io.Reader) {
 881         var local30 uint16
 882         {
 883                 p := &local30
 884                 *p = read16(r)
 885         }
 886         ((*(*(struct {
 887                 IDs []SoundID
 888         }))(obj)).IDs) = make([]SoundID, local30)
 889         for local31 := range (*(*(struct {
 890                 IDs []SoundID
 891         }))(obj)).IDs {
 892                 if err := pcall(func() {
 893                         (((*(*(struct {
 894                                 IDs []SoundID
 895                         }))(obj)).IDs)[local31]).deserialize(r)
 896                 }); err != nil {
 897                         if err == io.EOF {
 898                                 chk(io.EOF)
 899                         }
 900                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
 901                 }
 902         }
 903 }
 904
 905 func (obj *ToSrvNodeMetaFields) serialize(w io.Writer) {
 906         for local32 := range (*(*(struct {
 907                 Pos      [3]int16
 908                 Formname string
 909                 Fields   []Field
 910         }))(obj)).Pos {
 911                 {
 912                         x := ((*(*(struct {
 913                                 Pos      [3]int16
 914                                 Formname string
 915                                 Fields   []Field
 916                         }))(obj)).Pos)[local32]
 917                         write16(w, uint16(x))
 918                 }
 919         }
 920         if len(([]byte((*(*(struct {
 921                 Pos      [3]int16
 922                 Formname string
 923                 Fields   []Field
 924         }))(obj)).Formname))) > math.MaxUint16 {
 925                 chk(ErrTooLong)
 926         }
 927         {
 928                 x := uint16(len(([]byte((*(*(struct {
 929                         Pos      [3]int16
 930                         Formname string
 931                         Fields   []Field
 932                 }))(obj)).Formname))))
 933                 write16(w, uint16(x))
 934         }
 935         {
 936                 _, err := w.Write(([]byte((*(*(struct {
 937                         Pos      [3]int16
 938                         Formname string
 939                         Fields   []Field
 940                 }))(obj)).Formname))[:])
 941                 chk(err)
 942         }
 943         if len(((*(*(struct {
 944                 Pos      [3]int16
 945                 Formname string
 946                 Fields   []Field
 947         }))(obj)).Fields)) > math.MaxUint16 {
 948                 chk(ErrTooLong)
 949         }
 950         {
 951                 x := uint16(len(((*(*(struct {
 952                         Pos      [3]int16
 953                         Formname string
 954                         Fields   []Field
 955                 }))(obj)).Fields)))
 956                 write16(w, uint16(x))
 957         }
 958         for local33 := range (*(*(struct {
 959                 Pos      [3]int16
 960                 Formname string
 961                 Fields   []Field
 962         }))(obj)).Fields {
 963                 if err := pcall(func() {
 964                         (((*(*(struct {
 965                                 Pos      [3]int16
 966                                 Formname string
 967                                 Fields   []Field
 968                         }))(obj)).Fields)[local33]).serialize(w)
 969                 }); err != nil {
 970                         if err == io.EOF {
 971                                 chk(io.EOF)
 972                         }
 973                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
 974                 }
 975         }
 976 }
 977
 978 func (obj *ToSrvNodeMetaFields) deserialize(r io.Reader) {
 979         for local34 := range (*(*(struct {
 980                 Pos      [3]int16
 981                 Formname string
 982                 Fields   []Field
 983         }))(obj)).Pos {
 984                 {
 985                         p := &((*(*(struct {
 986                                 Pos      [3]int16
 987                                 Formname string
 988                                 Fields   []Field
 989                         }))(obj)).Pos)[local34]
 990                         *p = int16(read16(r))
 991                 }
 992         }
 993         var local35 []uint8
 994         var local36 uint16
 995         {
 996                 p := &local36
 997                 *p = read16(r)
 998         }
 999         (local35) = make([]uint8, local36)
1000         {
1001                 _, err := io.ReadFull(r, (local35)[:])
1002                 chk(err)
1003         }
1004         ((*(*(struct {
1005                 Pos      [3]int16
1006                 Formname string
1007                 Fields   []Field
1008         }))(obj)).Formname) = string(local35)
1009         var local37 uint16
1010         {
1011                 p := &local37
1012                 *p = read16(r)
1013         }
1014         ((*(*(struct {
1015                 Pos      [3]int16
1016                 Formname string
1017                 Fields   []Field
1018         }))(obj)).Fields) = make([]Field, local37)
1019         for local38 := range (*(*(struct {
1020                 Pos      [3]int16
1021                 Formname string
1022                 Fields   []Field
1023         }))(obj)).Fields {
1024                 if err := pcall(func() {
1025                         (((*(*(struct {
1026                                 Pos      [3]int16
1027                                 Formname string
1028                                 Fields   []Field
1029                         }))(obj)).Fields)[local38]).deserialize(r)
1030                 }); err != nil {
1031                         if err == io.EOF {
1032                                 chk(io.EOF)
1033                         }
1034                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
1035                 }
1036         }
1037 }
1038
1039 func (obj *ToSrvInvFields) serialize(w io.Writer) {
1040         if len(([]byte((*(*(struct {
1041                 Formname string
1042                 Fields   []Field
1043         }))(obj)).Formname))) > math.MaxUint16 {
1044                 chk(ErrTooLong)
1045         }
1046         {
1047                 x := uint16(len(([]byte((*(*(struct {
1048                         Formname string
1049                         Fields   []Field
1050                 }))(obj)).Formname))))
1051                 write16(w, uint16(x))
1052         }
1053         {
1054                 _, err := w.Write(([]byte((*(*(struct {
1055                         Formname string
1056                         Fields   []Field
1057                 }))(obj)).Formname))[:])
1058                 chk(err)
1059         }
1060         if len(((*(*(struct {
1061                 Formname string
1062                 Fields   []Field
1063         }))(obj)).Fields)) > math.MaxUint16 {
1064                 chk(ErrTooLong)
1065         }
1066         {
1067                 x := uint16(len(((*(*(struct {
1068                         Formname string
1069                         Fields   []Field
1070                 }))(obj)).Fields)))
1071                 write16(w, uint16(x))
1072         }
1073         for local39 := range (*(*(struct {
1074                 Formname string
1075                 Fields   []Field
1076         }))(obj)).Fields {
1077                 if err := pcall(func() {
1078                         (((*(*(struct {
1079                                 Formname string
1080                                 Fields   []Field
1081                         }))(obj)).Fields)[local39]).serialize(w)
1082                 }); err != nil {
1083                         if err == io.EOF {
1084                                 chk(io.EOF)
1085                         }
1086                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
1087                 }
1088         }
1089 }
1090
1091 func (obj *ToSrvInvFields) deserialize(r io.Reader) {
1092         var local40 []uint8
1093         var local41 uint16
1094         {
1095                 p := &local41
1096                 *p = read16(r)
1097         }
1098         (local40) = make([]uint8, local41)
1099         {
1100                 _, err := io.ReadFull(r, (local40)[:])
1101                 chk(err)
1102         }
1103         ((*(*(struct {
1104                 Formname string
1105                 Fields   []Field
1106         }))(obj)).Formname) = string(local40)
1107         var local42 uint16
1108         {
1109                 p := &local42
1110                 *p = read16(r)
1111         }
1112         ((*(*(struct {
1113                 Formname string
1114                 Fields   []Field
1115         }))(obj)).Fields) = make([]Field, local42)
1116         for local43 := range (*(*(struct {
1117                 Formname string
1118                 Fields   []Field
1119         }))(obj)).Fields {
1120                 if err := pcall(func() {
1121                         (((*(*(struct {
1122                                 Formname string
1123                                 Fields   []Field
1124                         }))(obj)).Fields)[local43]).deserialize(r)
1125                 }); err != nil {
1126                         if err == io.EOF {
1127                                 chk(io.EOF)
1128                         }
1129                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
1130                 }
1131         }
1132 }
1133
1134 func (obj *ToSrvReqMedia) serialize(w io.Writer) {
1135         if len(((*(*(struct {
1136                 Filenames []string
1137         }))(obj)).Filenames)) > math.MaxUint16 {
1138                 chk(ErrTooLong)
1139         }
1140         {
1141                 x := uint16(len(((*(*(struct {
1142                         Filenames []string
1143                 }))(obj)).Filenames)))
1144                 write16(w, uint16(x))
1145         }
1146         for local44 := range (*(*(struct {
1147                 Filenames []string
1148         }))(obj)).Filenames {
1149                 if len(([]byte(((*(*(struct {
1150                         Filenames []string
1151                 }))(obj)).Filenames)[local44]))) > math.MaxUint16 {
1152                         chk(ErrTooLong)
1153                 }
1154                 {
1155                         x := uint16(len(([]byte(((*(*(struct {
1156                                 Filenames []string
1157                         }))(obj)).Filenames)[local44]))))
1158                         write16(w, uint16(x))
1159                 }
1160                 {
1161                         _, err := w.Write(([]byte(((*(*(struct {
1162                                 Filenames []string
1163                         }))(obj)).Filenames)[local44]))[:])
1164                         chk(err)
1165                 }
1166         }
1167 }
1168
1169 func (obj *ToSrvReqMedia) deserialize(r io.Reader) {
1170         var local45 uint16
1171         {
1172                 p := &local45
1173                 *p = read16(r)
1174         }
1175         ((*(*(struct {
1176                 Filenames []string
1177         }))(obj)).Filenames) = make([]string, local45)
1178         for local46 := range (*(*(struct {
1179                 Filenames []string
1180         }))(obj)).Filenames {
1181                 var local47 []uint8
1182                 var local48 uint16
1183                 {
1184                         p := &local48
1185                         *p = read16(r)
1186                 }
1187                 (local47) = make([]uint8, local48)
1188                 {
1189                         _, err := io.ReadFull(r, (local47)[:])
1190                         chk(err)
1191                 }
1192                 (((*(*(struct {
1193                         Filenames []string
1194                 }))(obj)).Filenames)[local46]) = string(local47)
1195         }
1196 }
1197
1198 func (obj *ToSrvCltReady) serialize(w io.Writer) {
1199         {
1200                 x := (*(*(struct {
1201                         // Version information.
1202                         Major, Minor, Patch uint8
1203                         Reserved            uint8
1204                         Version             string
1205                         Formspec            uint16
1206                 }))(obj)).Major
1207                 write8(w, uint8(x))
1208         }
1209         {
1210                 x := (*(*(struct {
1211                         // Version information.
1212                         Major, Minor, Patch uint8
1213                         Reserved            uint8
1214                         Version             string
1215                         Formspec            uint16
1216                 }))(obj)).Minor
1217                 write8(w, uint8(x))
1218         }
1219         {
1220                 x := (*(*(struct {
1221                         // Version information.
1222                         Major, Minor, Patch uint8
1223                         Reserved            uint8
1224                         Version             string
1225                         Formspec            uint16
1226                 }))(obj)).Patch
1227                 write8(w, uint8(x))
1228         }
1229         {
1230                 x := (*(*(struct {
1231                         // Version information.
1232                         Major, Minor, Patch uint8
1233                         Reserved            uint8
1234                         Version             string
1235                         Formspec            uint16
1236                 }))(obj)).Reserved
1237                 write8(w, uint8(x))
1238         }
1239         if len(([]byte((*(*(struct {
1240                 // Version information.
1241                 Major, Minor, Patch uint8
1242                 Reserved            uint8
1243                 Version             string
1244                 Formspec            uint16
1245         }))(obj)).Version))) > math.MaxUint16 {
1246                 chk(ErrTooLong)
1247         }
1248         {
1249                 x := uint16(len(([]byte((*(*(struct {
1250                         // Version information.
1251                         Major, Minor, Patch uint8
1252                         Reserved            uint8
1253                         Version             string
1254                         Formspec            uint16
1255                 }))(obj)).Version))))
1256                 write16(w, uint16(x))
1257         }
1258         {
1259                 _, err := w.Write(([]byte((*(*(struct {
1260                         // Version information.
1261                         Major, Minor, Patch uint8
1262                         Reserved            uint8
1263                         Version             string
1264                         Formspec            uint16
1265                 }))(obj)).Version))[:])
1266                 chk(err)
1267         }
1268         {
1269                 x := (*(*(struct {
1270                         // Version information.
1271                         Major, Minor, Patch uint8
1272                         Reserved            uint8
1273                         Version             string
1274                         Formspec            uint16
1275                 }))(obj)).Formspec
1276                 write16(w, uint16(x))
1277         }
1278 }
1279
1280 func (obj *ToSrvCltReady) deserialize(r io.Reader) {
1281         {
1282                 p := &(*(*(struct {
1283                         // Version information.
1284                         Major, Minor, Patch uint8
1285                         Reserved            uint8
1286                         Version             string
1287                         Formspec            uint16
1288                 }))(obj)).Major
1289                 *p = read8(r)
1290         }
1291         {
1292                 p := &(*(*(struct {
1293                         // Version information.
1294                         Major, Minor, Patch uint8
1295                         Reserved            uint8
1296                         Version             string
1297                         Formspec            uint16
1298                 }))(obj)).Minor
1299                 *p = read8(r)
1300         }
1301         {
1302                 p := &(*(*(struct {
1303                         // Version information.
1304                         Major, Minor, Patch uint8
1305                         Reserved            uint8
1306                         Version             string
1307                         Formspec            uint16
1308                 }))(obj)).Patch
1309                 *p = read8(r)
1310         }
1311         {
1312                 p := &(*(*(struct {
1313                         // Version information.
1314                         Major, Minor, Patch uint8
1315                         Reserved            uint8
1316                         Version             string
1317                         Formspec            uint16
1318                 }))(obj)).Reserved
1319                 *p = read8(r)
1320         }
1321         var local49 []uint8
1322         var local50 uint16
1323         {
1324                 p := &local50
1325                 *p = read16(r)
1326         }
1327         (local49) = make([]uint8, local50)
1328         {
1329                 _, err := io.ReadFull(r, (local49)[:])
1330                 chk(err)
1331         }
1332         ((*(*(struct {
1333                 // Version information.
1334                 Major, Minor, Patch uint8
1335                 Reserved            uint8
1336                 Version             string
1337                 Formspec            uint16
1338         }))(obj)).Version) = string(local49)
1339         {
1340                 p := &(*(*(struct {
1341                         // Version information.
1342                         Major, Minor, Patch uint8
1343                         Reserved            uint8
1344                         Version             string
1345                         Formspec            uint16
1346                 }))(obj)).Formspec
1347                 *p = read16(r)
1348         }
1349 }
1350
1351 func (obj *ToSrvFirstSRP) serialize(w io.Writer) {
1352         if len(((*(*(struct {
1353                 Salt        []byte
1354                 Verifier    []byte
1355                 EmptyPasswd bool
1356         }))(obj)).Salt)) > math.MaxUint16 {
1357                 chk(ErrTooLong)
1358         }
1359         {
1360                 x := uint16(len(((*(*(struct {
1361                         Salt        []byte
1362                         Verifier    []byte
1363                         EmptyPasswd bool
1364                 }))(obj)).Salt)))
1365                 write16(w, uint16(x))
1366         }
1367         {
1368                 _, err := w.Write(((*(*(struct {
1369                         Salt        []byte
1370                         Verifier    []byte
1371                         EmptyPasswd bool
1372                 }))(obj)).Salt)[:])
1373                 chk(err)
1374         }
1375         if len(((*(*(struct {
1376                 Salt        []byte
1377                 Verifier    []byte
1378                 EmptyPasswd bool
1379         }))(obj)).Verifier)) > math.MaxUint16 {
1380                 chk(ErrTooLong)
1381         }
1382         {
1383                 x := uint16(len(((*(*(struct {
1384                         Salt        []byte
1385                         Verifier    []byte
1386                         EmptyPasswd bool
1387                 }))(obj)).Verifier)))
1388                 write16(w, uint16(x))
1389         }
1390         {
1391                 _, err := w.Write(((*(*(struct {
1392                         Salt        []byte
1393                         Verifier    []byte
1394                         EmptyPasswd bool
1395                 }))(obj)).Verifier)[:])
1396                 chk(err)
1397         }
1398         {
1399                 x := (*(*(struct {
1400                         Salt        []byte
1401                         Verifier    []byte
1402                         EmptyPasswd bool
1403                 }))(obj)).EmptyPasswd
1404                 if x {
1405                         write8(w, 1)
1406                 } else {
1407                         write8(w, 0)
1408                 }
1409         }
1410 }
1411
1412 func (obj *ToSrvFirstSRP) deserialize(r io.Reader) {
1413         var local51 uint16
1414         {
1415                 p := &local51
1416                 *p = read16(r)
1417         }
1418         ((*(*(struct {
1419                 Salt        []byte
1420                 Verifier    []byte
1421                 EmptyPasswd bool
1422         }))(obj)).Salt) = make([]byte, local51)
1423         {
1424                 _, err := io.ReadFull(r, ((*(*(struct {
1425                         Salt        []byte
1426                         Verifier    []byte
1427                         EmptyPasswd bool
1428                 }))(obj)).Salt)[:])
1429                 chk(err)
1430         }
1431         var local52 uint16
1432         {
1433                 p := &local52
1434                 *p = read16(r)
1435         }
1436         ((*(*(struct {
1437                 Salt        []byte
1438                 Verifier    []byte
1439                 EmptyPasswd bool
1440         }))(obj)).Verifier) = make([]byte, local52)
1441         {
1442                 _, err := io.ReadFull(r, ((*(*(struct {
1443                         Salt        []byte
1444                         Verifier    []byte
1445                         EmptyPasswd bool
1446                 }))(obj)).Verifier)[:])
1447                 chk(err)
1448         }
1449         {
1450                 p := &(*(*(struct {
1451                         Salt        []byte
1452                         Verifier    []byte
1453                         EmptyPasswd bool
1454                 }))(obj)).EmptyPasswd
1455                 switch n := read8(r); n {
1456                 case 0:
1457                         *p = false
1458                 case 1:
1459                         *p = true
1460                 default:
1461                         chk(fmt.Errorf("invalid bool: %d", n))
1462                 }
1463         }
1464 }
1465
1466 func (obj *ToSrvSRPBytesA) serialize(w io.Writer) {
1467         if len(((*(*(struct {
1468                 A      []byte
1469                 NoSHA1 bool
1470         }))(obj)).A)) > math.MaxUint16 {
1471                 chk(ErrTooLong)
1472         }
1473         {
1474                 x := uint16(len(((*(*(struct {
1475                         A      []byte
1476                         NoSHA1 bool
1477                 }))(obj)).A)))
1478                 write16(w, uint16(x))
1479         }
1480         {
1481                 _, err := w.Write(((*(*(struct {
1482                         A      []byte
1483                         NoSHA1 bool
1484                 }))(obj)).A)[:])
1485                 chk(err)
1486         }
1487         {
1488                 x := (*(*(struct {
1489                         A      []byte
1490                         NoSHA1 bool
1491                 }))(obj)).NoSHA1
1492                 if x {
1493                         write8(w, 1)
1494                 } else {
1495                         write8(w, 0)
1496                 }
1497         }
1498 }
1499
1500 func (obj *ToSrvSRPBytesA) deserialize(r io.Reader) {
1501         var local53 uint16
1502         {
1503                 p := &local53
1504                 *p = read16(r)
1505         }
1506         ((*(*(struct {
1507                 A      []byte
1508                 NoSHA1 bool
1509         }))(obj)).A) = make([]byte, local53)
1510         {
1511                 _, err := io.ReadFull(r, ((*(*(struct {
1512                         A      []byte
1513                         NoSHA1 bool
1514                 }))(obj)).A)[:])
1515                 chk(err)
1516         }
1517         {
1518                 p := &(*(*(struct {
1519                         A      []byte
1520                         NoSHA1 bool
1521                 }))(obj)).NoSHA1
1522                 switch n := read8(r); n {
1523                 case 0:
1524                         *p = false
1525                 case 1:
1526                         *p = true
1527                 default:
1528                         chk(fmt.Errorf("invalid bool: %d", n))
1529                 }
1530         }
1531 }
1532
1533 func (obj *ToSrvSRPBytesM) serialize(w io.Writer) {
1534         if len(((*(*(struct {
1535                 M []byte
1536         }))(obj)).M)) > math.MaxUint16 {
1537                 chk(ErrTooLong)
1538         }
1539         {
1540                 x := uint16(len(((*(*(struct {
1541                         M []byte
1542                 }))(obj)).M)))
1543                 write16(w, uint16(x))
1544         }
1545         {
1546                 _, err := w.Write(((*(*(struct {
1547                         M []byte
1548                 }))(obj)).M)[:])
1549                 chk(err)
1550         }
1551 }
1552
1553 func (obj *ToSrvSRPBytesM) deserialize(r io.Reader) {
1554         var local54 uint16
1555         {
1556                 p := &local54
1557                 *p = read16(r)
1558         }
1559         ((*(*(struct {
1560                 M []byte
1561         }))(obj)).M) = make([]byte, local54)
1562         {
1563                 _, err := io.ReadFull(r, ((*(*(struct {
1564                         M []byte
1565                 }))(obj)).M)[:])
1566                 chk(err)
1567         }
1568 }
1569
1570 func (obj *ToCltHello) serialize(w io.Writer) {
1571         {
1572                 x := (*(*(struct {
1573                         SerializeVer uint8
1574                         Compression  CompressionModes
1575                         ProtoVer     uint16
1576                         AuthMethods
1577                         Username string
1578                 }))(obj)).SerializeVer
1579                 write8(w, uint8(x))
1580         }
1581         if err := pcall(func() {
1582                 ((*(*(struct {
1583                         SerializeVer uint8
1584                         Compression  CompressionModes
1585                         ProtoVer     uint16
1586                         AuthMethods
1587                         Username string
1588                 }))(obj)).Compression).serialize(w)
1589         }); err != nil {
1590                 if err == io.EOF {
1591                         chk(io.EOF)
1592                 }
1593                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CompressionModes", err))
1594         }
1595         {
1596                 x := (*(*(struct {
1597                         SerializeVer uint8
1598                         Compression  CompressionModes
1599                         ProtoVer     uint16
1600                         AuthMethods
1601                         Username string
1602                 }))(obj)).ProtoVer
1603                 write16(w, uint16(x))
1604         }
1605         if err := pcall(func() {
1606                 ((*(*(struct {
1607                         SerializeVer uint8
1608                         Compression  CompressionModes
1609                         ProtoVer     uint16
1610                         AuthMethods
1611                         Username string
1612                 }))(obj)).AuthMethods).serialize(w)
1613         }); err != nil {
1614                 if err == io.EOF {
1615                         chk(io.EOF)
1616                 }
1617                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1618         }
1619         if len(([]byte((*(*(struct {
1620                 SerializeVer uint8
1621                 Compression  CompressionModes
1622                 ProtoVer     uint16
1623                 AuthMethods
1624                 Username string
1625         }))(obj)).Username))) > math.MaxUint16 {
1626                 chk(ErrTooLong)
1627         }
1628         {
1629                 x := uint16(len(([]byte((*(*(struct {
1630                         SerializeVer uint8
1631                         Compression  CompressionModes
1632                         ProtoVer     uint16
1633                         AuthMethods
1634                         Username string
1635                 }))(obj)).Username))))
1636                 write16(w, uint16(x))
1637         }
1638         {
1639                 _, err := w.Write(([]byte((*(*(struct {
1640                         SerializeVer uint8
1641                         Compression  CompressionModes
1642                         ProtoVer     uint16
1643                         AuthMethods
1644                         Username string
1645                 }))(obj)).Username))[:])
1646                 chk(err)
1647         }
1648 }
1649
1650 func (obj *ToCltHello) deserialize(r io.Reader) {
1651         {
1652                 p := &(*(*(struct {
1653                         SerializeVer uint8
1654                         Compression  CompressionModes
1655                         ProtoVer     uint16
1656                         AuthMethods
1657                         Username string
1658                 }))(obj)).SerializeVer
1659                 *p = read8(r)
1660         }
1661         if err := pcall(func() {
1662                 ((*(*(struct {
1663                         SerializeVer uint8
1664                         Compression  CompressionModes
1665                         ProtoVer     uint16
1666                         AuthMethods
1667                         Username string
1668                 }))(obj)).Compression).deserialize(r)
1669         }); err != nil {
1670                 if err == io.EOF {
1671                         chk(io.EOF)
1672                 }
1673                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CompressionModes", err))
1674         }
1675         {
1676                 p := &(*(*(struct {
1677                         SerializeVer uint8
1678                         Compression  CompressionModes
1679                         ProtoVer     uint16
1680                         AuthMethods
1681                         Username string
1682                 }))(obj)).ProtoVer
1683                 *p = read16(r)
1684         }
1685         if err := pcall(func() {
1686                 ((*(*(struct {
1687                         SerializeVer uint8
1688                         Compression  CompressionModes
1689                         ProtoVer     uint16
1690                         AuthMethods
1691                         Username string
1692                 }))(obj)).AuthMethods).deserialize(r)
1693         }); err != nil {
1694                 if err == io.EOF {
1695                         chk(io.EOF)
1696                 }
1697                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1698         }
1699         var local55 []uint8
1700         var local56 uint16
1701         {
1702                 p := &local56
1703                 *p = read16(r)
1704         }
1705         (local55) = make([]uint8, local56)
1706         {
1707                 _, err := io.ReadFull(r, (local55)[:])
1708                 chk(err)
1709         }
1710         ((*(*(struct {
1711                 SerializeVer uint8
1712                 Compression  CompressionModes
1713                 ProtoVer     uint16
1714                 AuthMethods
1715                 Username string
1716         }))(obj)).Username) = string(local55)
1717 }
1718
1719 func (obj *ToCltAcceptAuth) serialize(w io.Writer) {
1720         if err := pcall(func() {
1721                 ((*(*(struct {
1722                         // The client does the equivalent of
1723                         //      PlayerPos[1] -= 5
1724                         // before using PlayerPos.
1725                         PlayerPos Pos
1726
1727                         MapSeed         uint64
1728                         SendInterval    float32
1729                         SudoAuthMethods AuthMethods
1730                 }))(obj)).PlayerPos).serialize(w)
1731         }); err != nil {
1732                 if err == io.EOF {
1733                         chk(io.EOF)
1734                 }
1735                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
1736         }
1737         {
1738                 x := (*(*(struct {
1739                         // The client does the equivalent of
1740                         //      PlayerPos[1] -= 5
1741                         // before using PlayerPos.
1742                         PlayerPos Pos
1743
1744                         MapSeed         uint64
1745                         SendInterval    float32
1746                         SudoAuthMethods AuthMethods
1747                 }))(obj)).MapSeed
1748                 write64(w, uint64(x))
1749         }
1750         {
1751                 x := (*(*(struct {
1752                         // The client does the equivalent of
1753                         //      PlayerPos[1] -= 5
1754                         // before using PlayerPos.
1755                         PlayerPos Pos
1756
1757                         MapSeed         uint64
1758                         SendInterval    float32
1759                         SudoAuthMethods AuthMethods
1760                 }))(obj)).SendInterval
1761                 write32(w, math.Float32bits(x))
1762         }
1763         if err := pcall(func() {
1764                 ((*(*(struct {
1765                         // The client does the equivalent of
1766                         //      PlayerPos[1] -= 5
1767                         // before using PlayerPos.
1768                         PlayerPos Pos
1769
1770                         MapSeed         uint64
1771                         SendInterval    float32
1772                         SudoAuthMethods AuthMethods
1773                 }))(obj)).SudoAuthMethods).serialize(w)
1774         }); err != nil {
1775                 if err == io.EOF {
1776                         chk(io.EOF)
1777                 }
1778                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1779         }
1780 }
1781
1782 func (obj *ToCltAcceptAuth) deserialize(r io.Reader) {
1783         if err := pcall(func() {
1784                 ((*(*(struct {
1785                         // The client does the equivalent of
1786                         //      PlayerPos[1] -= 5
1787                         // before using PlayerPos.
1788                         PlayerPos Pos
1789
1790                         MapSeed         uint64
1791                         SendInterval    float32
1792                         SudoAuthMethods AuthMethods
1793                 }))(obj)).PlayerPos).deserialize(r)
1794         }); err != nil {
1795                 if err == io.EOF {
1796                         chk(io.EOF)
1797                 }
1798                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
1799         }
1800         {
1801                 p := &(*(*(struct {
1802                         // The client does the equivalent of
1803                         //      PlayerPos[1] -= 5
1804                         // before using PlayerPos.
1805                         PlayerPos Pos
1806
1807                         MapSeed         uint64
1808                         SendInterval    float32
1809                         SudoAuthMethods AuthMethods
1810                 }))(obj)).MapSeed
1811                 *p = read64(r)
1812         }
1813         {
1814                 p := &(*(*(struct {
1815                         // The client does the equivalent of
1816                         //      PlayerPos[1] -= 5
1817                         // before using PlayerPos.
1818                         PlayerPos Pos
1819
1820                         MapSeed         uint64
1821                         SendInterval    float32
1822                         SudoAuthMethods AuthMethods
1823                 }))(obj)).SendInterval
1824                 *p = math.Float32frombits(read32(r))
1825         }
1826         if err := pcall(func() {
1827                 ((*(*(struct {
1828                         // The client does the equivalent of
1829                         //      PlayerPos[1] -= 5
1830                         // before using PlayerPos.
1831                         PlayerPos Pos
1832
1833                         MapSeed         uint64
1834                         SendInterval    float32
1835                         SudoAuthMethods AuthMethods
1836                 }))(obj)).SudoAuthMethods).deserialize(r)
1837         }); err != nil {
1838                 if err == io.EOF {
1839                         chk(io.EOF)
1840                 }
1841                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1842         }
1843 }
1844
1845 func (obj *ToCltAcceptSudoMode) serialize(w io.Writer) {
1846         if err := pcall(func() {
1847                 ((*(*(struct {
1848                         SudoAuthMethods AuthMethods
1849                 }))(obj)).SudoAuthMethods).serialize(w)
1850         }); err != nil {
1851                 if err == io.EOF {
1852                         chk(io.EOF)
1853                 }
1854                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1855         }
1856         {
1857                 local57 := [15]byte{}
1858                 {
1859                         _, err := w.Write((local57)[:])
1860                         chk(err)
1861                 }
1862         }
1863 }
1864
1865 func (obj *ToCltAcceptSudoMode) deserialize(r io.Reader) {
1866         if err := pcall(func() {
1867                 ((*(*(struct {
1868                         SudoAuthMethods AuthMethods
1869                 }))(obj)).SudoAuthMethods).deserialize(r)
1870         }); err != nil {
1871                 if err == io.EOF {
1872                         chk(io.EOF)
1873                 }
1874                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AuthMethods", err))
1875         }
1876         {
1877                 var local58 [15]byte
1878                 local59 := [15]byte{}
1879                 {
1880                         _, err := io.ReadFull(r, (local58)[:])
1881                         chk(err)
1882                 }
1883                 if local58 != local59 {
1884                         chk(fmt.Errorf("const %v: %v", "[15]byte{}", local58))
1885                 }
1886         }
1887 }
1888
1889 func (obj *ToCltDenySudoMode) serialize(w io.Writer) {
1890 }
1891
1892 func (obj *ToCltDenySudoMode) deserialize(r io.Reader) {
1893 }
1894
1895 func (obj *ToCltKick) serialize(w io.Writer) {
1896         if err := pcall(func() {
1897                 ((*(*(struct {
1898                         Reason KickReason
1899
1900                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1901                         Custom string
1902
1903                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1904                         Reconnect bool
1905                 }))(obj)).Reason).serialize(w)
1906         }); err != nil {
1907                 if err == io.EOF {
1908                         chk(io.EOF)
1909                 }
1910                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.KickReason", err))
1911         }
1912         if !((*(*(struct {
1913                 Reason KickReason
1914
1915                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1916                 Custom string
1917
1918                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1919                 Reconnect bool
1920         }))(obj)).Reason < maxKickReason) {
1921                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
1922         }
1923         if dr := (*(*(struct {
1924                 Reason KickReason
1925
1926                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1927                 Custom string
1928
1929                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1930                 Reconnect bool
1931         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
1932                 if len(([]byte((*(*(struct {
1933                         Reason KickReason
1934
1935                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1936                         Custom string
1937
1938                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1939                         Reconnect bool
1940                 }))(obj)).Custom))) > math.MaxUint16 {
1941                         chk(ErrTooLong)
1942                 }
1943                 {
1944                         x := uint16(len(([]byte((*(*(struct {
1945                                 Reason KickReason
1946
1947                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1948                                 Custom string
1949
1950                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1951                                 Reconnect bool
1952                         }))(obj)).Custom))))
1953                         write16(w, uint16(x))
1954                 }
1955                 {
1956                         _, err := w.Write(([]byte((*(*(struct {
1957                                 Reason KickReason
1958
1959                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1960                                 Custom string
1961
1962                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1963                                 Reconnect bool
1964                         }))(obj)).Custom))[:])
1965                         chk(err)
1966                 }
1967         }
1968         if dr := (*(*(struct {
1969                 Reason KickReason
1970
1971                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1972                 Custom string
1973
1974                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1975                 Reconnect bool
1976         }))(obj)).Reason; dr == Shutdown || dr == Crash {
1977                 {
1978                         x := (*(*(struct {
1979                                 Reason KickReason
1980
1981                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
1982                                 Custom string
1983
1984                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
1985                                 Reconnect bool
1986                         }))(obj)).Reconnect
1987                         if x {
1988                                 write8(w, 1)
1989                         } else {
1990                                 write8(w, 0)
1991                         }
1992                 }
1993         }
1994 }
1995
1996 func (obj *ToCltKick) deserialize(r io.Reader) {
1997         if err := pcall(func() {
1998                 ((*(*(struct {
1999                         Reason KickReason
2000
2001                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2002                         Custom string
2003
2004                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2005                         Reconnect bool
2006                 }))(obj)).Reason).deserialize(r)
2007         }); err != nil {
2008                 if err == io.EOF {
2009                         chk(io.EOF)
2010                 }
2011                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.KickReason", err))
2012         }
2013         if !((*(*(struct {
2014                 Reason KickReason
2015
2016                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2017                 Custom string
2018
2019                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2020                 Reconnect bool
2021         }))(obj)).Reason < maxKickReason) {
2022                 chk(errors.New("assertion failed: %s.Reason < maxKickReason"))
2023         }
2024         if dr := (*(*(struct {
2025                 Reason KickReason
2026
2027                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2028                 Custom string
2029
2030                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2031                 Reconnect bool
2032         }))(obj)).Reason; dr == Custom || dr == Shutdown || dr == Crash {
2033                 var local60 []uint8
2034                 var local61 uint16
2035                 {
2036                         p := &local61
2037                         *p = read16(r)
2038                 }
2039                 (local60) = make([]uint8, local61)
2040                 {
2041                         _, err := io.ReadFull(r, (local60)[:])
2042                         chk(err)
2043                 }
2044                 ((*(*(struct {
2045                         Reason KickReason
2046
2047                         //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2048                         Custom string
2049
2050                         //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2051                         Reconnect bool
2052                 }))(obj)).Custom) = string(local60)
2053         }
2054         if dr := (*(*(struct {
2055                 Reason KickReason
2056
2057                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2058                 Custom string
2059
2060                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2061                 Reconnect bool
2062         }))(obj)).Reason; dr == Shutdown || dr == Crash {
2063                 {
2064                         p := &(*(*(struct {
2065                                 Reason KickReason
2066
2067                                 //mt:if dr := %s.Reason; dr == Custom || dr == Shutdown || dr == Crash
2068                                 Custom string
2069
2070                                 //mt:if dr := %s.Reason; dr == Shutdown || dr == Crash
2071                                 Reconnect bool
2072                         }))(obj)).Reconnect
2073                         switch n := read8(r); n {
2074                         case 0:
2075                                 *p = false
2076                         case 1:
2077                                 *p = true
2078                         default:
2079                                 chk(fmt.Errorf("invalid bool: %d", n))
2080                         }
2081                 }
2082         }
2083 }
2084
2085 func (obj *ToCltBlkData) serialize(w io.Writer) {
2086         for local62 := range (*(*(struct {
2087                 Blkpos [3]int16
2088                 Blk    MapBlk
2089         }))(obj)).Blkpos {
2090                 {
2091                         x := ((*(*(struct {
2092                                 Blkpos [3]int16
2093                                 Blk    MapBlk
2094                         }))(obj)).Blkpos)[local62]
2095                         write16(w, uint16(x))
2096                 }
2097         }
2098         if err := pcall(func() {
2099                 ((*(*(struct {
2100                         Blkpos [3]int16
2101                         Blk    MapBlk
2102                 }))(obj)).Blk).serialize(w)
2103         }); err != nil {
2104                 if err == io.EOF {
2105                         chk(io.EOF)
2106                 }
2107                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlk", err))
2108         }
2109 }
2110
2111 func (obj *ToCltBlkData) deserialize(r io.Reader) {
2112         for local63 := range (*(*(struct {
2113                 Blkpos [3]int16
2114                 Blk    MapBlk
2115         }))(obj)).Blkpos {
2116                 {
2117                         p := &((*(*(struct {
2118                                 Blkpos [3]int16
2119                                 Blk    MapBlk
2120                         }))(obj)).Blkpos)[local63]
2121                         *p = int16(read16(r))
2122                 }
2123         }
2124         if err := pcall(func() {
2125                 ((*(*(struct {
2126                         Blkpos [3]int16
2127                         Blk    MapBlk
2128                 }))(obj)).Blk).deserialize(r)
2129         }); err != nil {
2130                 if err == io.EOF {
2131                         chk(io.EOF)
2132                 }
2133                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlk", err))
2134         }
2135 }
2136
2137 func (obj *ToCltAddNode) serialize(w io.Writer) {
2138         for local64 := range (*(*(struct {
2139                 Pos [3]int16
2140                 Node
2141                 KeepMeta bool
2142         }))(obj)).Pos {
2143                 {
2144                         x := ((*(*(struct {
2145                                 Pos [3]int16
2146                                 Node
2147                                 KeepMeta bool
2148                         }))(obj)).Pos)[local64]
2149                         write16(w, uint16(x))
2150                 }
2151         }
2152         if err := pcall(func() {
2153                 ((*(*(struct {
2154                         Pos [3]int16
2155                         Node
2156                         KeepMeta bool
2157                 }))(obj)).Node).serialize(w)
2158         }); err != nil {
2159                 if err == io.EOF {
2160                         chk(io.EOF)
2161                 }
2162                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Node", err))
2163         }
2164         {
2165                 x := (*(*(struct {
2166                         Pos [3]int16
2167                         Node
2168                         KeepMeta bool
2169                 }))(obj)).KeepMeta
2170                 if x {
2171                         write8(w, 1)
2172                 } else {
2173                         write8(w, 0)
2174                 }
2175         }
2176 }
2177
2178 func (obj *ToCltAddNode) deserialize(r io.Reader) {
2179         for local65 := range (*(*(struct {
2180                 Pos [3]int16
2181                 Node
2182                 KeepMeta bool
2183         }))(obj)).Pos {
2184                 {
2185                         p := &((*(*(struct {
2186                                 Pos [3]int16
2187                                 Node
2188                                 KeepMeta bool
2189                         }))(obj)).Pos)[local65]
2190                         *p = int16(read16(r))
2191                 }
2192         }
2193         if err := pcall(func() {
2194                 ((*(*(struct {
2195                         Pos [3]int16
2196                         Node
2197                         KeepMeta bool
2198                 }))(obj)).Node).deserialize(r)
2199         }); err != nil {
2200                 if err == io.EOF {
2201                         chk(io.EOF)
2202                 }
2203                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Node", err))
2204         }
2205         {
2206                 p := &(*(*(struct {
2207                         Pos [3]int16
2208                         Node
2209                         KeepMeta bool
2210                 }))(obj)).KeepMeta
2211                 switch n := read8(r); n {
2212                 case 0:
2213                         *p = false
2214                 case 1:
2215                         *p = true
2216                 default:
2217                         chk(fmt.Errorf("invalid bool: %d", n))
2218                 }
2219         }
2220 }
2221
2222 func (obj *ToCltRemoveNode) serialize(w io.Writer) {
2223         for local66 := range (*(*(struct {
2224                 Pos [3]int16
2225         }))(obj)).Pos {
2226                 {
2227                         x := ((*(*(struct {
2228                                 Pos [3]int16
2229                         }))(obj)).Pos)[local66]
2230                         write16(w, uint16(x))
2231                 }
2232         }
2233 }
2234
2235 func (obj *ToCltRemoveNode) deserialize(r io.Reader) {
2236         for local67 := range (*(*(struct {
2237                 Pos [3]int16
2238         }))(obj)).Pos {
2239                 {
2240                         p := &((*(*(struct {
2241                                 Pos [3]int16
2242                         }))(obj)).Pos)[local67]
2243                         *p = int16(read16(r))
2244                 }
2245         }
2246 }
2247
2248 func (obj *ToCltInv) serialize(w io.Writer) {
2249         {
2250                 _, err := w.Write(([]byte((*(*(struct {
2251                         //mt:raw
2252                         Inv string
2253                 }))(obj)).Inv))[:])
2254                 chk(err)
2255         }
2256 }
2257
2258 func (obj *ToCltInv) deserialize(r io.Reader) {
2259         var local68 []uint8
2260         {
2261                 var err error
2262                 (local68), err = io.ReadAll(r)
2263                 chk(err)
2264         }
2265         ((*(*(struct {
2266                 //mt:raw
2267                 Inv string
2268         }))(obj)).Inv) = string(local68)
2269 }
2270
2271 func (obj *ToCltTimeOfDay) serialize(w io.Writer) {
2272         {
2273                 x := (*(*(struct {
2274                         Time  uint16  // %24000
2275                         Speed float32 // Speed times faster than real time
2276                 }))(obj)).Time
2277                 write16(w, uint16(x))
2278         }
2279         {
2280                 x := (*(*(struct {
2281                         Time  uint16  // %24000
2282                         Speed float32 // Speed times faster than real time
2283                 }))(obj)).Speed
2284                 write32(w, math.Float32bits(x))
2285         }
2286 }
2287
2288 func (obj *ToCltTimeOfDay) deserialize(r io.Reader) {
2289         {
2290                 p := &(*(*(struct {
2291                         Time  uint16  // %24000
2292                         Speed float32 // Speed times faster than real time
2293                 }))(obj)).Time
2294                 *p = read16(r)
2295         }
2296         {
2297                 p := &(*(*(struct {
2298                         Time  uint16  // %24000
2299                         Speed float32 // Speed times faster than real time
2300                 }))(obj)).Speed
2301                 *p = math.Float32frombits(read32(r))
2302         }
2303 }
2304
2305 func (obj *ToCltCSMRestrictionFlags) serialize(w io.Writer) {
2306         if err := pcall(func() {
2307                 ((*(*(struct {
2308                         Flags CSMRestrictionFlags
2309
2310                         // MapRange is the maximum distance from the player CSMs can read the map
2311                         // if Flags&LimitMapRange != 0.
2312                         MapRange uint32
2313                 }))(obj)).Flags).serialize(w)
2314         }); err != nil {
2315                 if err == io.EOF {
2316                         chk(io.EOF)
2317                 }
2318                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CSMRestrictionFlags", err))
2319         }
2320         {
2321                 x := (*(*(struct {
2322                         Flags CSMRestrictionFlags
2323
2324                         // MapRange is the maximum distance from the player CSMs can read the map
2325                         // if Flags&LimitMapRange != 0.
2326                         MapRange uint32
2327                 }))(obj)).MapRange
2328                 write32(w, uint32(x))
2329         }
2330 }
2331
2332 func (obj *ToCltCSMRestrictionFlags) deserialize(r io.Reader) {
2333         if err := pcall(func() {
2334                 ((*(*(struct {
2335                         Flags CSMRestrictionFlags
2336
2337                         // MapRange is the maximum distance from the player CSMs can read the map
2338                         // if Flags&LimitMapRange != 0.
2339                         MapRange uint32
2340                 }))(obj)).Flags).deserialize(r)
2341         }); err != nil {
2342                 if err == io.EOF {
2343                         chk(io.EOF)
2344                 }
2345                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.CSMRestrictionFlags", err))
2346         }
2347         {
2348                 p := &(*(*(struct {
2349                         Flags CSMRestrictionFlags
2350
2351                         // MapRange is the maximum distance from the player CSMs can read the map
2352                         // if Flags&LimitMapRange != 0.
2353                         MapRange uint32
2354                 }))(obj)).MapRange
2355                 *p = read32(r)
2356         }
2357 }
2358
2359 func (obj *ToCltAddPlayerVel) serialize(w io.Writer) {
2360         if err := pcall(func() {
2361                 ((*(*(struct {
2362                         Vel Vec
2363                 }))(obj)).Vel).serialize(w)
2364         }); err != nil {
2365                 if err == io.EOF {
2366                         chk(io.EOF)
2367                 }
2368                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
2369         }
2370 }
2371
2372 func (obj *ToCltAddPlayerVel) deserialize(r io.Reader) {
2373         if err := pcall(func() {
2374                 ((*(*(struct {
2375                         Vel Vec
2376                 }))(obj)).Vel).deserialize(r)
2377         }); err != nil {
2378                 if err == io.EOF {
2379                         chk(io.EOF)
2380                 }
2381                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
2382         }
2383 }
2384
2385 func (obj *ToCltMediaPush) serialize(w io.Writer) {
2386         if len(([]byte((*(*(struct {
2387                 RawHash       string
2388                 Filename      string
2389                 CallbackToken uint32
2390                 ShouldCache   bool
2391         }))(obj)).RawHash))) > math.MaxUint16 {
2392                 chk(ErrTooLong)
2393         }
2394         {
2395                 x := uint16(len(([]byte((*(*(struct {
2396                         RawHash       string
2397                         Filename      string
2398                         CallbackToken uint32
2399                         ShouldCache   bool
2400                 }))(obj)).RawHash))))
2401                 write16(w, uint16(x))
2402         }
2403         {
2404                 _, err := w.Write(([]byte((*(*(struct {
2405                         RawHash       string
2406                         Filename      string
2407                         CallbackToken uint32
2408                         ShouldCache   bool
2409                 }))(obj)).RawHash))[:])
2410                 chk(err)
2411         }
2412         if len(([]byte((*(*(struct {
2413                 RawHash       string
2414                 Filename      string
2415                 CallbackToken uint32
2416                 ShouldCache   bool
2417         }))(obj)).Filename))) > math.MaxUint16 {
2418                 chk(ErrTooLong)
2419         }
2420         {
2421                 x := uint16(len(([]byte((*(*(struct {
2422                         RawHash       string
2423                         Filename      string
2424                         CallbackToken uint32
2425                         ShouldCache   bool
2426                 }))(obj)).Filename))))
2427                 write16(w, uint16(x))
2428         }
2429         {
2430                 _, err := w.Write(([]byte((*(*(struct {
2431                         RawHash       string
2432                         Filename      string
2433                         CallbackToken uint32
2434                         ShouldCache   bool
2435                 }))(obj)).Filename))[:])
2436                 chk(err)
2437         }
2438         {
2439                 x := (*(*(struct {
2440                         RawHash       string
2441                         Filename      string
2442                         CallbackToken uint32
2443                         ShouldCache   bool
2444                 }))(obj)).CallbackToken
2445                 write32(w, uint32(x))
2446         }
2447         {
2448                 x := (*(*(struct {
2449                         RawHash       string
2450                         Filename      string
2451                         CallbackToken uint32
2452                         ShouldCache   bool
2453                 }))(obj)).ShouldCache
2454                 if x {
2455                         write8(w, 1)
2456                 } else {
2457                         write8(w, 0)
2458                 }
2459         }
2460 }
2461
2462 func (obj *ToCltMediaPush) deserialize(r io.Reader) {
2463         var local69 []uint8
2464         var local70 uint16
2465         {
2466                 p := &local70
2467                 *p = read16(r)
2468         }
2469         (local69) = make([]uint8, local70)
2470         {
2471                 _, err := io.ReadFull(r, (local69)[:])
2472                 chk(err)
2473         }
2474         ((*(*(struct {
2475                 RawHash       string
2476                 Filename      string
2477                 CallbackToken uint32
2478                 ShouldCache   bool
2479         }))(obj)).RawHash) = string(local69)
2480         var local71 []uint8
2481         var local72 uint16
2482         {
2483                 p := &local72
2484                 *p = read16(r)
2485         }
2486         (local71) = make([]uint8, local72)
2487         {
2488                 _, err := io.ReadFull(r, (local71)[:])
2489                 chk(err)
2490         }
2491         ((*(*(struct {
2492                 RawHash       string
2493                 Filename      string
2494                 CallbackToken uint32
2495                 ShouldCache   bool
2496         }))(obj)).Filename) = string(local71)
2497         {
2498                 p := &(*(*(struct {
2499                         RawHash       string
2500                         Filename      string
2501                         CallbackToken uint32
2502                         ShouldCache   bool
2503                 }))(obj)).CallbackToken
2504                 *p = read32(r)
2505         }
2506         {
2507                 p := &(*(*(struct {
2508                         RawHash       string
2509                         Filename      string
2510                         CallbackToken uint32
2511                         ShouldCache   bool
2512                 }))(obj)).ShouldCache
2513                 switch n := read8(r); n {
2514                 case 0:
2515                         *p = false
2516                 case 1:
2517                         *p = true
2518                 default:
2519                         chk(fmt.Errorf("invalid bool: %d", n))
2520                 }
2521         }
2522 }
2523
2524 func (obj *ToCltChatMsg) serialize(w io.Writer) {
2525         {
2526                 local73 := uint8(1)
2527                 {
2528                         x := local73
2529                         write8(w, uint8(x))
2530                 }
2531         }
2532         if err := pcall(func() {
2533                 ((*(*(struct {
2534                         Type ChatMsgType
2535
2536                         //mt:utf16
2537                         Sender, Text string
2538
2539                         Timestamp int64 // Unix time.
2540                 }))(obj)).Type).serialize(w)
2541         }); err != nil {
2542                 if err == io.EOF {
2543                         chk(io.EOF)
2544                 }
2545                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ChatMsgType", err))
2546         }
2547         local74 := utf16.Encode([]rune((*(*(struct {
2548                 Type ChatMsgType
2549
2550                 //mt:utf16
2551                 Sender, Text string
2552
2553                 Timestamp int64 // Unix time.
2554         }))(obj)).Sender))
2555         if len((local74)) > math.MaxUint16 {
2556                 chk(ErrTooLong)
2557         }
2558         {
2559                 x := uint16(len((local74)))
2560                 write16(w, uint16(x))
2561         }
2562         for local75 := range local74 {
2563                 {
2564                         x := (local74)[local75]
2565                         write16(w, uint16(x))
2566                 }
2567         }
2568         local76 := utf16.Encode([]rune((*(*(struct {
2569                 Type ChatMsgType
2570
2571                 //mt:utf16
2572                 Sender, Text string
2573
2574                 Timestamp int64 // Unix time.
2575         }))(obj)).Text))
2576         if len((local76)) > math.MaxUint16 {
2577                 chk(ErrTooLong)
2578         }
2579         {
2580                 x := uint16(len((local76)))
2581                 write16(w, uint16(x))
2582         }
2583         for local77 := range local76 {
2584                 {
2585                         x := (local76)[local77]
2586                         write16(w, uint16(x))
2587                 }
2588         }
2589         {
2590                 x := (*(*(struct {
2591                         Type ChatMsgType
2592
2593                         //mt:utf16
2594                         Sender, Text string
2595
2596                         Timestamp int64 // Unix time.
2597                 }))(obj)).Timestamp
2598                 write64(w, uint64(x))
2599         }
2600 }
2601
2602 func (obj *ToCltChatMsg) deserialize(r io.Reader) {
2603         {
2604                 var local78 uint8
2605                 local79 := uint8(1)
2606                 {
2607                         p := &local78
2608                         *p = read8(r)
2609                 }
2610                 if local78 != local79 {
2611                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local78))
2612                 }
2613         }
2614         if err := pcall(func() {
2615                 ((*(*(struct {
2616                         Type ChatMsgType
2617
2618                         //mt:utf16
2619                         Sender, Text string
2620
2621                         Timestamp int64 // Unix time.
2622                 }))(obj)).Type).deserialize(r)
2623         }); err != nil {
2624                 if err == io.EOF {
2625                         chk(io.EOF)
2626                 }
2627                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ChatMsgType", err))
2628         }
2629         var local80 []uint16
2630         var local81 uint16
2631         {
2632                 p := &local81
2633                 *p = read16(r)
2634         }
2635         (local80) = make([]uint16, local81)
2636         for local82 := range local80 {
2637                 {
2638                         p := &(local80)[local82]
2639                         *p = read16(r)
2640                 }
2641         }
2642         (*(*(struct {
2643                 Type ChatMsgType
2644
2645                 //mt:utf16
2646                 Sender, Text string
2647
2648                 Timestamp int64 // Unix time.
2649         }))(obj)).Sender = string(utf16.Decode(local80))
2650         var local83 []uint16
2651         var local84 uint16
2652         {
2653                 p := &local84
2654                 *p = read16(r)
2655         }
2656         (local83) = make([]uint16, local84)
2657         for local85 := range local83 {
2658                 {
2659                         p := &(local83)[local85]
2660                         *p = read16(r)
2661                 }
2662         }
2663         (*(*(struct {
2664                 Type ChatMsgType
2665
2666                 //mt:utf16
2667                 Sender, Text string
2668
2669                 Timestamp int64 // Unix time.
2670         }))(obj)).Text = string(utf16.Decode(local83))
2671         {
2672                 p := &(*(*(struct {
2673                         Type ChatMsgType
2674
2675                         //mt:utf16
2676                         Sender, Text string
2677
2678                         Timestamp int64 // Unix time.
2679                 }))(obj)).Timestamp
2680                 *p = int64(read64(r))
2681         }
2682 }
2683
2684 func (obj *ToCltAORmAdd) serialize(w io.Writer) {
2685         if len(((*(*(struct {
2686                 Remove []AOID
2687                 Add    []AOAdd
2688         }))(obj)).Remove)) > math.MaxUint16 {
2689                 chk(ErrTooLong)
2690         }
2691         {
2692                 x := uint16(len(((*(*(struct {
2693                         Remove []AOID
2694                         Add    []AOAdd
2695                 }))(obj)).Remove)))
2696                 write16(w, uint16(x))
2697         }
2698         for local86 := range (*(*(struct {
2699                 Remove []AOID
2700                 Add    []AOAdd
2701         }))(obj)).Remove {
2702                 if err := pcall(func() {
2703                         (((*(*(struct {
2704                                 Remove []AOID
2705                                 Add    []AOAdd
2706                         }))(obj)).Remove)[local86]).serialize(w)
2707                 }); err != nil {
2708                         if err == io.EOF {
2709                                 chk(io.EOF)
2710                         }
2711                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
2712                 }
2713         }
2714         if len(((*(*(struct {
2715                 Remove []AOID
2716                 Add    []AOAdd
2717         }))(obj)).Add)) > math.MaxUint16 {
2718                 chk(ErrTooLong)
2719         }
2720         {
2721                 x := uint16(len(((*(*(struct {
2722                         Remove []AOID
2723                         Add    []AOAdd
2724                 }))(obj)).Add)))
2725                 write16(w, uint16(x))
2726         }
2727         for local87 := range (*(*(struct {
2728                 Remove []AOID
2729                 Add    []AOAdd
2730         }))(obj)).Add {
2731                 if err := pcall(func() {
2732                         (((*(*(struct {
2733                                 Remove []AOID
2734                                 Add    []AOAdd
2735                         }))(obj)).Add)[local87]).serialize(w)
2736                 }); err != nil {
2737                         if err == io.EOF {
2738                                 chk(io.EOF)
2739                         }
2740                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAdd", err))
2741                 }
2742         }
2743 }
2744
2745 func (obj *ToCltAORmAdd) deserialize(r io.Reader) {
2746         var local88 uint16
2747         {
2748                 p := &local88
2749                 *p = read16(r)
2750         }
2751         ((*(*(struct {
2752                 Remove []AOID
2753                 Add    []AOAdd
2754         }))(obj)).Remove) = make([]AOID, local88)
2755         for local89 := range (*(*(struct {
2756                 Remove []AOID
2757                 Add    []AOAdd
2758         }))(obj)).Remove {
2759                 if err := pcall(func() {
2760                         (((*(*(struct {
2761                                 Remove []AOID
2762                                 Add    []AOAdd
2763                         }))(obj)).Remove)[local89]).deserialize(r)
2764                 }); err != nil {
2765                         if err == io.EOF {
2766                                 chk(io.EOF)
2767                         }
2768                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
2769                 }
2770         }
2771         var local90 uint16
2772         {
2773                 p := &local90
2774                 *p = read16(r)
2775         }
2776         ((*(*(struct {
2777                 Remove []AOID
2778                 Add    []AOAdd
2779         }))(obj)).Add) = make([]AOAdd, local90)
2780         for local91 := range (*(*(struct {
2781                 Remove []AOID
2782                 Add    []AOAdd
2783         }))(obj)).Add {
2784                 if err := pcall(func() {
2785                         (((*(*(struct {
2786                                 Remove []AOID
2787                                 Add    []AOAdd
2788                         }))(obj)).Add)[local91]).deserialize(r)
2789                 }); err != nil {
2790                         if err == io.EOF {
2791                                 chk(io.EOF)
2792                         }
2793                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAdd", err))
2794                 }
2795         }
2796 }
2797
2798 func (obj *ToCltAOMsgs) serialize(w io.Writer) {
2799         for local92 := range (*(*(struct {
2800                 //mt:raw
2801                 Msgs []IDAOMsg
2802         }))(obj)).Msgs {
2803                 if err := pcall(func() {
2804                         (((*(*(struct {
2805                                 //mt:raw
2806                                 Msgs []IDAOMsg
2807                         }))(obj)).Msgs)[local92]).serialize(w)
2808                 }); err != nil {
2809                         if err == io.EOF {
2810                                 chk(io.EOF)
2811                         }
2812                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.IDAOMsg", err))
2813                 }
2814         }
2815 }
2816
2817 func (obj *ToCltAOMsgs) deserialize(r io.Reader) {
2818         for {
2819                 var local93 IDAOMsg
2820                 err := pcall(func() {
2821                         if err := pcall(func() {
2822                                 (local93).deserialize(r)
2823                         }); err != nil {
2824                                 if err == io.EOF {
2825                                         chk(io.EOF)
2826                                 }
2827                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.IDAOMsg", err))
2828                         }
2829                 })
2830                 if err == io.EOF {
2831                         break
2832                 }
2833                 ((*(*(struct {
2834                         //mt:raw
2835                         Msgs []IDAOMsg
2836                 }))(obj)).Msgs) = append(((*(*(struct {
2837                         //mt:raw
2838                         Msgs []IDAOMsg
2839                 }))(obj)).Msgs), local93)
2840                 chk(err)
2841         }
2842 }
2843
2844 func (obj *ToCltHP) serialize(w io.Writer) {
2845         {
2846                 x := (*(*(struct {
2847                         HP uint16
2848                 }))(obj)).HP
2849                 write16(w, uint16(x))
2850         }
2851 }
2852
2853 func (obj *ToCltHP) deserialize(r io.Reader) {
2854         {
2855                 p := &(*(*(struct {
2856                         HP uint16
2857                 }))(obj)).HP
2858                 *p = read16(r)
2859         }
2860 }
2861
2862 func (obj *ToCltMovePlayer) serialize(w io.Writer) {
2863         if err := pcall(func() {
2864                 ((*(*(struct {
2865                         Pos
2866                         Pitch, Yaw float32
2867                 }))(obj)).Pos).serialize(w)
2868         }); err != nil {
2869                 if err == io.EOF {
2870                         chk(io.EOF)
2871                 }
2872                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
2873         }
2874         {
2875                 x := (*(*(struct {
2876                         Pos
2877                         Pitch, Yaw float32
2878                 }))(obj)).Pitch
2879                 write32(w, math.Float32bits(x))
2880         }
2881         {
2882                 x := (*(*(struct {
2883                         Pos
2884                         Pitch, Yaw float32
2885                 }))(obj)).Yaw
2886                 write32(w, math.Float32bits(x))
2887         }
2888 }
2889
2890 func (obj *ToCltMovePlayer) deserialize(r io.Reader) {
2891         if err := pcall(func() {
2892                 ((*(*(struct {
2893                         Pos
2894                         Pitch, Yaw float32
2895                 }))(obj)).Pos).deserialize(r)
2896         }); err != nil {
2897                 if err == io.EOF {
2898                         chk(io.EOF)
2899                 }
2900                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
2901         }
2902         {
2903                 p := &(*(*(struct {
2904                         Pos
2905                         Pitch, Yaw float32
2906                 }))(obj)).Pitch
2907                 *p = math.Float32frombits(read32(r))
2908         }
2909         {
2910                 p := &(*(*(struct {
2911                         Pos
2912                         Pitch, Yaw float32
2913                 }))(obj)).Yaw
2914                 *p = math.Float32frombits(read32(r))
2915         }
2916 }
2917
2918 func (obj *ToCltLegacyKick) serialize(w io.Writer) {
2919         local94 := utf16.Encode([]rune((*(*(struct {
2920                 //mt:utf16
2921                 Reason string
2922         }))(obj)).Reason))
2923         if len((local94)) > math.MaxUint16 {
2924                 chk(ErrTooLong)
2925         }
2926         {
2927                 x := uint16(len((local94)))
2928                 write16(w, uint16(x))
2929         }
2930         for local95 := range local94 {
2931                 {
2932                         x := (local94)[local95]
2933                         write16(w, uint16(x))
2934                 }
2935         }
2936 }
2937
2938 func (obj *ToCltLegacyKick) deserialize(r io.Reader) {
2939         var local96 []uint16
2940         var local97 uint16
2941         {
2942                 p := &local97
2943                 *p = read16(r)
2944         }
2945         (local96) = make([]uint16, local97)
2946         for local98 := range local96 {
2947                 {
2948                         p := &(local96)[local98]
2949                         *p = read16(r)
2950                 }
2951         }
2952         (*(*(struct {
2953                 //mt:utf16
2954                 Reason string
2955         }))(obj)).Reason = string(utf16.Decode(local96))
2956 }
2957
2958 func (obj *ToCltFOV) serialize(w io.Writer) {
2959         {
2960                 x := (*(*(struct {
2961                         FOV            float32
2962                         Multiplier     bool
2963                         TransitionTime float32
2964                 }))(obj)).FOV
2965                 write32(w, math.Float32bits(x))
2966         }
2967         {
2968                 x := (*(*(struct {
2969                         FOV            float32
2970                         Multiplier     bool
2971                         TransitionTime float32
2972                 }))(obj)).Multiplier
2973                 if x {
2974                         write8(w, 1)
2975                 } else {
2976                         write8(w, 0)
2977                 }
2978         }
2979         {
2980                 x := (*(*(struct {
2981                         FOV            float32
2982                         Multiplier     bool
2983                         TransitionTime float32
2984                 }))(obj)).TransitionTime
2985                 write32(w, math.Float32bits(x))
2986         }
2987 }
2988
2989 func (obj *ToCltFOV) deserialize(r io.Reader) {
2990         {
2991                 p := &(*(*(struct {
2992                         FOV            float32
2993                         Multiplier     bool
2994                         TransitionTime float32
2995                 }))(obj)).FOV
2996                 *p = math.Float32frombits(read32(r))
2997         }
2998         {
2999                 p := &(*(*(struct {
3000                         FOV            float32
3001                         Multiplier     bool
3002                         TransitionTime float32
3003                 }))(obj)).Multiplier
3004                 switch n := read8(r); n {
3005                 case 0:
3006                         *p = false
3007                 case 1:
3008                         *p = true
3009                 default:
3010                         chk(fmt.Errorf("invalid bool: %d", n))
3011                 }
3012         }
3013         {
3014                 p := &(*(*(struct {
3015                         FOV            float32
3016                         Multiplier     bool
3017                         TransitionTime float32
3018                 }))(obj)).TransitionTime
3019                 *p = math.Float32frombits(read32(r))
3020         }
3021 }
3022
3023 func (obj *ToCltDeathScreen) serialize(w io.Writer) {
3024         {
3025                 x := (*(*(struct {
3026                         PointCam bool
3027                         PointAt  Pos
3028                 }))(obj)).PointCam
3029                 if x {
3030                         write8(w, 1)
3031                 } else {
3032                         write8(w, 0)
3033                 }
3034         }
3035         if err := pcall(func() {
3036                 ((*(*(struct {
3037                         PointCam bool
3038                         PointAt  Pos
3039                 }))(obj)).PointAt).serialize(w)
3040         }); err != nil {
3041                 if err == io.EOF {
3042                         chk(io.EOF)
3043                 }
3044                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
3045         }
3046 }
3047
3048 func (obj *ToCltDeathScreen) deserialize(r io.Reader) {
3049         {
3050                 p := &(*(*(struct {
3051                         PointCam bool
3052                         PointAt  Pos
3053                 }))(obj)).PointCam
3054                 switch n := read8(r); n {
3055                 case 0:
3056                         *p = false
3057                 case 1:
3058                         *p = true
3059                 default:
3060                         chk(fmt.Errorf("invalid bool: %d", n))
3061                 }
3062         }
3063         if err := pcall(func() {
3064                 ((*(*(struct {
3065                         PointCam bool
3066                         PointAt  Pos
3067                 }))(obj)).PointAt).deserialize(r)
3068         }); err != nil {
3069                 if err == io.EOF {
3070                         chk(io.EOF)
3071                 }
3072                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
3073         }
3074 }
3075
3076 func (obj *ToCltMedia) serialize(w io.Writer) {
3077         {
3078                 x := (*(*(struct {
3079                         // N is the total number of ToCltMedia packets.
3080                         // I is the index of this packet.
3081                         N, I uint16
3082
3083                         //mt:len32
3084                         Files []struct {
3085                                 Name string
3086
3087                                 //mt:len32
3088                                 Data []byte
3089                         }
3090                 }))(obj)).N
3091                 write16(w, uint16(x))
3092         }
3093         {
3094                 x := (*(*(struct {
3095                         // N is the total number of ToCltMedia packets.
3096                         // I is the index of this packet.
3097                         N, I uint16
3098
3099                         //mt:len32
3100                         Files []struct {
3101                                 Name string
3102
3103                                 //mt:len32
3104                                 Data []byte
3105                         }
3106                 }))(obj)).I
3107                 write16(w, uint16(x))
3108         }
3109         if len(((*(*(struct {
3110                 // N is the total number of ToCltMedia packets.
3111                 // I is the index of this packet.
3112                 N, I uint16
3113
3114                 //mt:len32
3115                 Files []struct {
3116                         Name string
3117
3118                         //mt:len32
3119                         Data []byte
3120                 }
3121         }))(obj)).Files)) > math.MaxUint32 {
3122                 chk(ErrTooLong)
3123         }
3124         {
3125                 x := uint32(len(((*(*(struct {
3126                         // N is the total number of ToCltMedia packets.
3127                         // I is the index of this packet.
3128                         N, I uint16
3129
3130                         //mt:len32
3131                         Files []struct {
3132                                 Name string
3133
3134                                 //mt:len32
3135                                 Data []byte
3136                         }
3137                 }))(obj)).Files)))
3138                 write32(w, uint32(x))
3139         }
3140         for local99 := range (*(*(struct {
3141                 // N is the total number of ToCltMedia packets.
3142                 // I is the index of this packet.
3143                 N, I uint16
3144
3145                 //mt:len32
3146                 Files []struct {
3147                         Name string
3148
3149                         //mt:len32
3150                         Data []byte
3151                 }
3152         }))(obj)).Files {
3153                 if len(([]byte((((*(*(struct {
3154                         // N is the total number of ToCltMedia packets.
3155                         // I is the index of this packet.
3156                         N, I uint16
3157
3158                         //mt:len32
3159                         Files []struct {
3160                                 Name string
3161
3162                                 //mt:len32
3163                                 Data []byte
3164                         }
3165                 }))(obj)).Files)[local99]).Name))) > math.MaxUint16 {
3166                         chk(ErrTooLong)
3167                 }
3168                 {
3169                         x := uint16(len(([]byte((((*(*(struct {
3170                                 // N is the total number of ToCltMedia packets.
3171                                 // I is the index of this packet.
3172                                 N, I uint16
3173
3174                                 //mt:len32
3175                                 Files []struct {
3176                                         Name string
3177
3178                                         //mt:len32
3179                                         Data []byte
3180                                 }
3181                         }))(obj)).Files)[local99]).Name))))
3182                         write16(w, uint16(x))
3183                 }
3184                 {
3185                         _, err := w.Write(([]byte((((*(*(struct {
3186                                 // N is the total number of ToCltMedia packets.
3187                                 // I is the index of this packet.
3188                                 N, I uint16
3189
3190                                 //mt:len32
3191                                 Files []struct {
3192                                         Name string
3193
3194                                         //mt:len32
3195                                         Data []byte
3196                                 }
3197                         }))(obj)).Files)[local99]).Name))[:])
3198                         chk(err)
3199                 }
3200                 if len(((((*(*(struct {
3201                         // N is the total number of ToCltMedia packets.
3202                         // I is the index of this packet.
3203                         N, I uint16
3204
3205                         //mt:len32
3206                         Files []struct {
3207                                 Name string
3208
3209                                 //mt:len32
3210                                 Data []byte
3211                         }
3212                 }))(obj)).Files)[local99]).Data)) > math.MaxUint32 {
3213                         chk(ErrTooLong)
3214                 }
3215                 {
3216                         x := uint32(len(((((*(*(struct {
3217                                 // N is the total number of ToCltMedia packets.
3218                                 // I is the index of this packet.
3219                                 N, I uint16
3220
3221                                 //mt:len32
3222                                 Files []struct {
3223                                         Name string
3224
3225                                         //mt:len32
3226                                         Data []byte
3227                                 }
3228                         }))(obj)).Files)[local99]).Data)))
3229                         write32(w, uint32(x))
3230                 }
3231                 {
3232                         _, err := w.Write(((((*(*(struct {
3233                                 // N is the total number of ToCltMedia packets.
3234                                 // I is the index of this packet.
3235                                 N, I uint16
3236
3237                                 //mt:len32
3238                                 Files []struct {
3239                                         Name string
3240
3241                                         //mt:len32
3242                                         Data []byte
3243                                 }
3244                         }))(obj)).Files)[local99]).Data)[:])
3245                         chk(err)
3246                 }
3247         }
3248 }
3249
3250 func (obj *ToCltMedia) deserialize(r io.Reader) {
3251         {
3252                 p := &(*(*(struct {
3253                         // N is the total number of ToCltMedia packets.
3254                         // I is the index of this packet.
3255                         N, I uint16
3256
3257                         //mt:len32
3258                         Files []struct {
3259                                 Name string
3260
3261                                 //mt:len32
3262                                 Data []byte
3263                         }
3264                 }))(obj)).N
3265                 *p = read16(r)
3266         }
3267         {
3268                 p := &(*(*(struct {
3269                         // N is the total number of ToCltMedia packets.
3270                         // I is the index of this packet.
3271                         N, I uint16
3272
3273                         //mt:len32
3274                         Files []struct {
3275                                 Name string
3276
3277                                 //mt:len32
3278                                 Data []byte
3279                         }
3280                 }))(obj)).I
3281                 *p = read16(r)
3282         }
3283         var local100 uint32
3284         {
3285                 p := &local100
3286                 *p = read32(r)
3287         }
3288         ((*(*(struct {
3289                 // N is the total number of ToCltMedia packets.
3290                 // I is the index of this packet.
3291                 N, I uint16
3292
3293                 //mt:len32
3294                 Files []struct {
3295                         Name string
3296
3297                         //mt:len32
3298                         Data []byte
3299                 }
3300         }))(obj)).Files) = make([]struct {
3301                 Name string
3302                 Data []byte
3303         }, local100)
3304         for local101 := range (*(*(struct {
3305                 // N is the total number of ToCltMedia packets.
3306                 // I is the index of this packet.
3307                 N, I uint16
3308
3309                 //mt:len32
3310                 Files []struct {
3311                         Name string
3312
3313                         //mt:len32
3314                         Data []byte
3315                 }
3316         }))(obj)).Files {
3317                 var local102 []uint8
3318                 var local103 uint16
3319                 {
3320                         p := &local103
3321                         *p = read16(r)
3322                 }
3323                 (local102) = make([]uint8, local103)
3324                 {
3325                         _, err := io.ReadFull(r, (local102)[:])
3326                         chk(err)
3327                 }
3328                 ((((*(*(struct {
3329                         // N is the total number of ToCltMedia packets.
3330                         // I is the index of this packet.
3331                         N, I uint16
3332
3333                         //mt:len32
3334                         Files []struct {
3335                                 Name string
3336
3337                                 //mt:len32
3338                                 Data []byte
3339                         }
3340                 }))(obj)).Files)[local101]).Name) = string(local102)
3341                 var local104 uint32
3342                 {
3343                         p := &local104
3344                         *p = read32(r)
3345                 }
3346                 ((((*(*(struct {
3347                         // N is the total number of ToCltMedia packets.
3348                         // I is the index of this packet.
3349                         N, I uint16
3350
3351                         //mt:len32
3352                         Files []struct {
3353                                 Name string
3354
3355                                 //mt:len32
3356                                 Data []byte
3357                         }
3358                 }))(obj)).Files)[local101]).Data) = make([]byte, local104)
3359                 {
3360                         _, err := io.ReadFull(r, ((((*(*(struct {
3361                                 // N is the total number of ToCltMedia packets.
3362                                 // I is the index of this packet.
3363                                 N, I uint16
3364
3365                                 //mt:len32
3366                                 Files []struct {
3367                                         Name string
3368
3369                                         //mt:len32
3370                                         Data []byte
3371                                 }
3372                         }))(obj)).Files)[local101]).Data)[:])
3373                         chk(err)
3374                 }
3375         }
3376 }
3377
3378 func (obj *ToCltNodeDefs) serialize(w io.Writer) {
3379         {
3380                 ow := w
3381                 w := new(bytes.Buffer)
3382                 {
3383                         w := zlib.NewWriter(w)
3384                         {
3385                                 local105 := uint8(1)
3386                                 {
3387                                         x := local105
3388                                         write8(w, uint8(x))
3389                                 }
3390                         }
3391                         {
3392                                 x := (*(*(struct {
3393
3394                                         // See (de)serialize.fmt.
3395                                         Defs []NodeDef
3396                                 }))(obj)).Defs
3397                                 { // For ToCltNodeDefs.Defs.
3398                                         if len(x) > math.MaxUint16 {
3399                                                 chk(ErrTooLong)
3400                                         }
3401                                         write16(w, uint16(len(x)))
3402                                         var b bytes.Buffer
3403                                         for i := range x {
3404                                                 x[i].serialize(&b)
3405                                         }
3406                                         if b.Len() > math.MaxUint32 {
3407                                                 chk(ErrTooLong)
3408                                         }
3409                                         write32(w, uint32(b.Len()))
3410                                         _, err := b.WriteTo(w)
3411                                         chk(err)
3412                                 }
3413                         }
3414                         chk(w.Close())
3415                 }
3416                 {
3417                         buf := w
3418                         w := ow
3419                         if len((buf.Bytes())) > math.MaxUint32 {
3420                                 chk(ErrTooLong)
3421                         }
3422                         {
3423                                 x := uint32(len((buf.Bytes())))
3424                                 write32(w, uint32(x))
3425                         }
3426                         {
3427                                 _, err := w.Write((buf.Bytes())[:])
3428                                 chk(err)
3429                         }
3430                 }
3431         }
3432 }
3433
3434 func (obj *ToCltNodeDefs) deserialize(r io.Reader) {
3435         {
3436                 var n uint32
3437                 {
3438                         p := &n
3439                         *p = read32(r)
3440                 }
3441                 r := &io.LimitedReader{R: r, N: int64(n)}
3442                 {
3443                         r, err := zlib.NewReader(byteReader{r})
3444                         chk(err)
3445                         {
3446                                 var local106 uint8
3447                                 local107 := uint8(1)
3448                                 {
3449                                         p := &local106
3450                                         *p = read8(r)
3451                                 }
3452                                 if local106 != local107 {
3453                                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local106))
3454                                 }
3455                         }
3456                         {
3457                                 p := &(*(*(struct {
3458
3459                                         // See (de)serialize.fmt.
3460                                         Defs []NodeDef
3461                                 }))(obj)).Defs
3462                                 { // For ToCltNodeDefs.Defs.
3463                                         *p = make([]NodeDef, read16(r))
3464                                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
3465                                         for i := range *p {
3466                                                 (*p)[i].deserialize(r)
3467                                         }
3468                                         if r.N > 0 {
3469                                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
3470                                         }
3471                                 }
3472                         }
3473                         chk(r.Close())
3474                 }
3475                 if r.N > 0 {
3476                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3477                 }
3478         }
3479 }
3480
3481 func (obj *ToCltAnnounceMedia) serialize(w io.Writer) {
3482         if len(((*(*(struct {
3483                 Files []struct {
3484                         Name       string
3485                         Base64SHA1 string
3486                 }
3487                 URL string
3488         }))(obj)).Files)) > math.MaxUint16 {
3489                 chk(ErrTooLong)
3490         }
3491         {
3492                 x := uint16(len(((*(*(struct {
3493                         Files []struct {
3494                                 Name       string
3495                                 Base64SHA1 string
3496                         }
3497                         URL string
3498                 }))(obj)).Files)))
3499                 write16(w, uint16(x))
3500         }
3501         for local108 := range (*(*(struct {
3502                 Files []struct {
3503                         Name       string
3504                         Base64SHA1 string
3505                 }
3506                 URL string
3507         }))(obj)).Files {
3508                 if len(([]byte((((*(*(struct {
3509                         Files []struct {
3510                                 Name       string
3511                                 Base64SHA1 string
3512                         }
3513                         URL string
3514                 }))(obj)).Files)[local108]).Name))) > math.MaxUint16 {
3515                         chk(ErrTooLong)
3516                 }
3517                 {
3518                         x := uint16(len(([]byte((((*(*(struct {
3519                                 Files []struct {
3520                                         Name       string
3521                                         Base64SHA1 string
3522                                 }
3523                                 URL string
3524                         }))(obj)).Files)[local108]).Name))))
3525                         write16(w, uint16(x))
3526                 }
3527                 {
3528                         _, err := w.Write(([]byte((((*(*(struct {
3529                                 Files []struct {
3530                                         Name       string
3531                                         Base64SHA1 string
3532                                 }
3533                                 URL string
3534                         }))(obj)).Files)[local108]).Name))[:])
3535                         chk(err)
3536                 }
3537                 if len(([]byte((((*(*(struct {
3538                         Files []struct {
3539                                 Name       string
3540                                 Base64SHA1 string
3541                         }
3542                         URL string
3543                 }))(obj)).Files)[local108]).Base64SHA1))) > math.MaxUint16 {
3544                         chk(ErrTooLong)
3545                 }
3546                 {
3547                         x := uint16(len(([]byte((((*(*(struct {
3548                                 Files []struct {
3549                                         Name       string
3550                                         Base64SHA1 string
3551                                 }
3552                                 URL string
3553                         }))(obj)).Files)[local108]).Base64SHA1))))
3554                         write16(w, uint16(x))
3555                 }
3556                 {
3557                         _, err := w.Write(([]byte((((*(*(struct {
3558                                 Files []struct {
3559                                         Name       string
3560                                         Base64SHA1 string
3561                                 }
3562                                 URL string
3563                         }))(obj)).Files)[local108]).Base64SHA1))[:])
3564                         chk(err)
3565                 }
3566         }
3567         if len(([]byte((*(*(struct {
3568                 Files []struct {
3569                         Name       string
3570                         Base64SHA1 string
3571                 }
3572                 URL string
3573         }))(obj)).URL))) > math.MaxUint16 {
3574                 chk(ErrTooLong)
3575         }
3576         {
3577                 x := uint16(len(([]byte((*(*(struct {
3578                         Files []struct {
3579                                 Name       string
3580                                 Base64SHA1 string
3581                         }
3582                         URL string
3583                 }))(obj)).URL))))
3584                 write16(w, uint16(x))
3585         }
3586         {
3587                 _, err := w.Write(([]byte((*(*(struct {
3588                         Files []struct {
3589                                 Name       string
3590                                 Base64SHA1 string
3591                         }
3592                         URL string
3593                 }))(obj)).URL))[:])
3594                 chk(err)
3595         }
3596 }
3597
3598 func (obj *ToCltAnnounceMedia) deserialize(r io.Reader) {
3599         var local109 uint16
3600         {
3601                 p := &local109
3602                 *p = read16(r)
3603         }
3604         ((*(*(struct {
3605                 Files []struct {
3606                         Name       string
3607                         Base64SHA1 string
3608                 }
3609                 URL string
3610         }))(obj)).Files) = make([]struct {
3611                 Name       string
3612                 Base64SHA1 string
3613         }, local109)
3614         for local110 := range (*(*(struct {
3615                 Files []struct {
3616                         Name       string
3617                         Base64SHA1 string
3618                 }
3619                 URL string
3620         }))(obj)).Files {
3621                 var local111 []uint8
3622                 var local112 uint16
3623                 {
3624                         p := &local112
3625                         *p = read16(r)
3626                 }
3627                 (local111) = make([]uint8, local112)
3628                 {
3629                         _, err := io.ReadFull(r, (local111)[:])
3630                         chk(err)
3631                 }
3632                 ((((*(*(struct {
3633                         Files []struct {
3634                                 Name       string
3635                                 Base64SHA1 string
3636                         }
3637                         URL string
3638                 }))(obj)).Files)[local110]).Name) = string(local111)
3639                 var local113 []uint8
3640                 var local114 uint16
3641                 {
3642                         p := &local114
3643                         *p = read16(r)
3644                 }
3645                 (local113) = make([]uint8, local114)
3646                 {
3647                         _, err := io.ReadFull(r, (local113)[:])
3648                         chk(err)
3649                 }
3650                 ((((*(*(struct {
3651                         Files []struct {
3652                                 Name       string
3653                                 Base64SHA1 string
3654                         }
3655                         URL string
3656                 }))(obj)).Files)[local110]).Base64SHA1) = string(local113)
3657         }
3658         var local115 []uint8
3659         var local116 uint16
3660         {
3661                 p := &local116
3662                 *p = read16(r)
3663         }
3664         (local115) = make([]uint8, local116)
3665         {
3666                 _, err := io.ReadFull(r, (local115)[:])
3667                 chk(err)
3668         }
3669         ((*(*(struct {
3670                 Files []struct {
3671                         Name       string
3672                         Base64SHA1 string
3673                 }
3674                 URL string
3675         }))(obj)).URL) = string(local115)
3676 }
3677
3678 func (obj *ToCltItemDefs) serialize(w io.Writer) {
3679         {
3680                 ow := w
3681                 w := new(bytes.Buffer)
3682                 {
3683                         w := zlib.NewWriter(w)
3684                         {
3685                                 local117 := uint8(0)
3686                                 {
3687                                         x := local117
3688                                         write8(w, uint8(x))
3689                                 }
3690                         }
3691                         if len(((*(*(struct {
3692                                 Defs    []ItemDef
3693                                 Aliases []struct{ Alias, Orig string }
3694                         }))(obj)).Defs)) > math.MaxUint16 {
3695                                 chk(ErrTooLong)
3696                         }
3697                         {
3698                                 x := uint16(len(((*(*(struct {
3699                                         Defs    []ItemDef
3700                                         Aliases []struct{ Alias, Orig string }
3701                                 }))(obj)).Defs)))
3702                                 write16(w, uint16(x))
3703                         }
3704                         for local118 := range (*(*(struct {
3705                                 Defs    []ItemDef
3706                                 Aliases []struct{ Alias, Orig string }
3707                         }))(obj)).Defs {
3708                                 if err := pcall(func() {
3709                                         (((*(*(struct {
3710                                                 Defs    []ItemDef
3711                                                 Aliases []struct{ Alias, Orig string }
3712                                         }))(obj)).Defs)[local118]).serialize(w)
3713                                 }); err != nil {
3714                                         if err == io.EOF {
3715                                                 chk(io.EOF)
3716                                         }
3717                                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemDef", err))
3718                                 }
3719                         }
3720                         if len(((*(*(struct {
3721                                 Defs    []ItemDef
3722                                 Aliases []struct{ Alias, Orig string }
3723                         }))(obj)).Aliases)) > math.MaxUint16 {
3724                                 chk(ErrTooLong)
3725                         }
3726                         {
3727                                 x := uint16(len(((*(*(struct {
3728                                         Defs    []ItemDef
3729                                         Aliases []struct{ Alias, Orig string }
3730                                 }))(obj)).Aliases)))
3731                                 write16(w, uint16(x))
3732                         }
3733                         for local119 := range (*(*(struct {
3734                                 Defs    []ItemDef
3735                                 Aliases []struct{ Alias, Orig string }
3736                         }))(obj)).Aliases {
3737                                 if len(([]byte((((*(*(struct {
3738                                         Defs    []ItemDef
3739                                         Aliases []struct{ Alias, Orig string }
3740                                 }))(obj)).Aliases)[local119]).Alias))) > math.MaxUint16 {
3741                                         chk(ErrTooLong)
3742                                 }
3743                                 {
3744                                         x := uint16(len(([]byte((((*(*(struct {
3745                                                 Defs    []ItemDef
3746                                                 Aliases []struct{ Alias, Orig string }
3747                                         }))(obj)).Aliases)[local119]).Alias))))
3748                                         write16(w, uint16(x))
3749                                 }
3750                                 {
3751                                         _, err := w.Write(([]byte((((*(*(struct {
3752                                                 Defs    []ItemDef
3753                                                 Aliases []struct{ Alias, Orig string }
3754                                         }))(obj)).Aliases)[local119]).Alias))[:])
3755                                         chk(err)
3756                                 }
3757                                 if len(([]byte((((*(*(struct {
3758                                         Defs    []ItemDef
3759                                         Aliases []struct{ Alias, Orig string }
3760                                 }))(obj)).Aliases)[local119]).Orig))) > math.MaxUint16 {
3761                                         chk(ErrTooLong)
3762                                 }
3763                                 {
3764                                         x := uint16(len(([]byte((((*(*(struct {
3765                                                 Defs    []ItemDef
3766                                                 Aliases []struct{ Alias, Orig string }
3767                                         }))(obj)).Aliases)[local119]).Orig))))
3768                                         write16(w, uint16(x))
3769                                 }
3770                                 {
3771                                         _, err := w.Write(([]byte((((*(*(struct {
3772                                                 Defs    []ItemDef
3773                                                 Aliases []struct{ Alias, Orig string }
3774                                         }))(obj)).Aliases)[local119]).Orig))[:])
3775                                         chk(err)
3776                                 }
3777                         }
3778                         chk(w.Close())
3779                 }
3780                 {
3781                         buf := w
3782                         w := ow
3783                         if len((buf.Bytes())) > math.MaxUint32 {
3784                                 chk(ErrTooLong)
3785                         }
3786                         {
3787                                 x := uint32(len((buf.Bytes())))
3788                                 write32(w, uint32(x))
3789                         }
3790                         {
3791                                 _, err := w.Write((buf.Bytes())[:])
3792                                 chk(err)
3793                         }
3794                 }
3795         }
3796 }
3797
3798 func (obj *ToCltItemDefs) deserialize(r io.Reader) {
3799         {
3800                 var n uint32
3801                 {
3802                         p := &n
3803                         *p = read32(r)
3804                 }
3805                 r := &io.LimitedReader{R: r, N: int64(n)}
3806                 {
3807                         r, err := zlib.NewReader(byteReader{r})
3808                         chk(err)
3809                         {
3810                                 var local120 uint8
3811                                 local121 := uint8(0)
3812                                 {
3813                                         p := &local120
3814                                         *p = read8(r)
3815                                 }
3816                                 if local120 != local121 {
3817                                         chk(fmt.Errorf("const %v: %v", "uint8(0)", local120))
3818                                 }
3819                         }
3820                         var local122 uint16
3821                         {
3822                                 p := &local122
3823                                 *p = read16(r)
3824                         }
3825                         ((*(*(struct {
3826                                 Defs    []ItemDef
3827                                 Aliases []struct{ Alias, Orig string }
3828                         }))(obj)).Defs) = make([]ItemDef, local122)
3829                         for local123 := range (*(*(struct {
3830                                 Defs    []ItemDef
3831                                 Aliases []struct{ Alias, Orig string }
3832                         }))(obj)).Defs {
3833                                 if err := pcall(func() {
3834                                         (((*(*(struct {
3835                                                 Defs    []ItemDef
3836                                                 Aliases []struct{ Alias, Orig string }
3837                                         }))(obj)).Defs)[local123]).deserialize(r)
3838                                 }); err != nil {
3839                                         if err == io.EOF {
3840                                                 chk(io.EOF)
3841                                         }
3842                                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemDef", err))
3843                                 }
3844                         }
3845                         var local124 uint16
3846                         {
3847                                 p := &local124
3848                                 *p = read16(r)
3849                         }
3850                         ((*(*(struct {
3851                                 Defs    []ItemDef
3852                                 Aliases []struct{ Alias, Orig string }
3853                         }))(obj)).Aliases) = make([]struct {
3854                                 Alias string
3855                                 Orig  string
3856                         }, local124)
3857                         for local125 := range (*(*(struct {
3858                                 Defs    []ItemDef
3859                                 Aliases []struct{ Alias, Orig string }
3860                         }))(obj)).Aliases {
3861                                 var local126 []uint8
3862                                 var local127 uint16
3863                                 {
3864                                         p := &local127
3865                                         *p = read16(r)
3866                                 }
3867                                 (local126) = make([]uint8, local127)
3868                                 {
3869                                         _, err := io.ReadFull(r, (local126)[:])
3870                                         chk(err)
3871                                 }
3872                                 ((((*(*(struct {
3873                                         Defs    []ItemDef
3874                                         Aliases []struct{ Alias, Orig string }
3875                                 }))(obj)).Aliases)[local125]).Alias) = string(local126)
3876                                 var local128 []uint8
3877                                 var local129 uint16
3878                                 {
3879                                         p := &local129
3880                                         *p = read16(r)
3881                                 }
3882                                 (local128) = make([]uint8, local129)
3883                                 {
3884                                         _, err := io.ReadFull(r, (local128)[:])
3885                                         chk(err)
3886                                 }
3887                                 ((((*(*(struct {
3888                                         Defs    []ItemDef
3889                                         Aliases []struct{ Alias, Orig string }
3890                                 }))(obj)).Aliases)[local125]).Orig) = string(local128)
3891                         }
3892                         chk(r.Close())
3893                 }
3894                 if r.N > 0 {
3895                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
3896                 }
3897         }
3898 }
3899
3900 func (obj *ToCltPlaySound) serialize(w io.Writer) {
3901         if err := pcall(func() {
3902                 ((*(*(struct {
3903                         ID      SoundID
3904                         Name    string
3905                         Gain    float32
3906                         SrcType SoundSrcType
3907                         Pos
3908                         SrcAOID   AOID
3909                         Loop      bool
3910                         Fade      float32
3911                         Pitch     float32
3912                         Ephemeral bool
3913                 }))(obj)).ID).serialize(w)
3914         }); err != nil {
3915                 if err == io.EOF {
3916                         chk(io.EOF)
3917                 }
3918                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
3919         }
3920         if len(([]byte((*(*(struct {
3921                 ID      SoundID
3922                 Name    string
3923                 Gain    float32
3924                 SrcType SoundSrcType
3925                 Pos
3926                 SrcAOID   AOID
3927                 Loop      bool
3928                 Fade      float32
3929                 Pitch     float32
3930                 Ephemeral bool
3931         }))(obj)).Name))) > math.MaxUint16 {
3932                 chk(ErrTooLong)
3933         }
3934         {
3935                 x := uint16(len(([]byte((*(*(struct {
3936                         ID      SoundID
3937                         Name    string
3938                         Gain    float32
3939                         SrcType SoundSrcType
3940                         Pos
3941                         SrcAOID   AOID
3942                         Loop      bool
3943                         Fade      float32
3944                         Pitch     float32
3945                         Ephemeral bool
3946                 }))(obj)).Name))))
3947                 write16(w, uint16(x))
3948         }
3949         {
3950                 _, err := w.Write(([]byte((*(*(struct {
3951                         ID      SoundID
3952                         Name    string
3953                         Gain    float32
3954                         SrcType SoundSrcType
3955                         Pos
3956                         SrcAOID   AOID
3957                         Loop      bool
3958                         Fade      float32
3959                         Pitch     float32
3960                         Ephemeral bool
3961                 }))(obj)).Name))[:])
3962                 chk(err)
3963         }
3964         {
3965                 x := (*(*(struct {
3966                         ID      SoundID
3967                         Name    string
3968                         Gain    float32
3969                         SrcType SoundSrcType
3970                         Pos
3971                         SrcAOID   AOID
3972                         Loop      bool
3973                         Fade      float32
3974                         Pitch     float32
3975                         Ephemeral bool
3976                 }))(obj)).Gain
3977                 write32(w, math.Float32bits(x))
3978         }
3979         if err := pcall(func() {
3980                 ((*(*(struct {
3981                         ID      SoundID
3982                         Name    string
3983                         Gain    float32
3984                         SrcType SoundSrcType
3985                         Pos
3986                         SrcAOID   AOID
3987                         Loop      bool
3988                         Fade      float32
3989                         Pitch     float32
3990                         Ephemeral bool
3991                 }))(obj)).SrcType).serialize(w)
3992         }); err != nil {
3993                 if err == io.EOF {
3994                         chk(io.EOF)
3995                 }
3996                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundSrcType", err))
3997         }
3998         if err := pcall(func() {
3999                 ((*(*(struct {
4000                         ID      SoundID
4001                         Name    string
4002                         Gain    float32
4003                         SrcType SoundSrcType
4004                         Pos
4005                         SrcAOID   AOID
4006                         Loop      bool
4007                         Fade      float32
4008                         Pitch     float32
4009                         Ephemeral bool
4010                 }))(obj)).Pos).serialize(w)
4011         }); err != nil {
4012                 if err == io.EOF {
4013                         chk(io.EOF)
4014                 }
4015                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
4016         }
4017         if err := pcall(func() {
4018                 ((*(*(struct {
4019                         ID      SoundID
4020                         Name    string
4021                         Gain    float32
4022                         SrcType SoundSrcType
4023                         Pos
4024                         SrcAOID   AOID
4025                         Loop      bool
4026                         Fade      float32
4027                         Pitch     float32
4028                         Ephemeral bool
4029                 }))(obj)).SrcAOID).serialize(w)
4030         }); err != nil {
4031                 if err == io.EOF {
4032                         chk(io.EOF)
4033                 }
4034                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
4035         }
4036         {
4037                 x := (*(*(struct {
4038                         ID      SoundID
4039                         Name    string
4040                         Gain    float32
4041                         SrcType SoundSrcType
4042                         Pos
4043                         SrcAOID   AOID
4044                         Loop      bool
4045                         Fade      float32
4046                         Pitch     float32
4047                         Ephemeral bool
4048                 }))(obj)).Loop
4049                 if x {
4050                         write8(w, 1)
4051                 } else {
4052                         write8(w, 0)
4053                 }
4054         }
4055         {
4056                 x := (*(*(struct {
4057                         ID      SoundID
4058                         Name    string
4059                         Gain    float32
4060                         SrcType SoundSrcType
4061                         Pos
4062                         SrcAOID   AOID
4063                         Loop      bool
4064                         Fade      float32
4065                         Pitch     float32
4066                         Ephemeral bool
4067                 }))(obj)).Fade
4068                 write32(w, math.Float32bits(x))
4069         }
4070         {
4071                 x := (*(*(struct {
4072                         ID      SoundID
4073                         Name    string
4074                         Gain    float32
4075                         SrcType SoundSrcType
4076                         Pos
4077                         SrcAOID   AOID
4078                         Loop      bool
4079                         Fade      float32
4080                         Pitch     float32
4081                         Ephemeral bool
4082                 }))(obj)).Pitch
4083                 write32(w, math.Float32bits(x))
4084         }
4085         {
4086                 x := (*(*(struct {
4087                         ID      SoundID
4088                         Name    string
4089                         Gain    float32
4090                         SrcType SoundSrcType
4091                         Pos
4092                         SrcAOID   AOID
4093                         Loop      bool
4094                         Fade      float32
4095                         Pitch     float32
4096                         Ephemeral bool
4097                 }))(obj)).Ephemeral
4098                 if x {
4099                         write8(w, 1)
4100                 } else {
4101                         write8(w, 0)
4102                 }
4103         }
4104 }
4105
4106 func (obj *ToCltPlaySound) deserialize(r io.Reader) {
4107         if err := pcall(func() {
4108                 ((*(*(struct {
4109                         ID      SoundID
4110                         Name    string
4111                         Gain    float32
4112                         SrcType SoundSrcType
4113                         Pos
4114                         SrcAOID   AOID
4115                         Loop      bool
4116                         Fade      float32
4117                         Pitch     float32
4118                         Ephemeral bool
4119                 }))(obj)).ID).deserialize(r)
4120         }); err != nil {
4121                 if err == io.EOF {
4122                         chk(io.EOF)
4123                 }
4124                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4125         }
4126         var local130 []uint8
4127         var local131 uint16
4128         {
4129                 p := &local131
4130                 *p = read16(r)
4131         }
4132         (local130) = make([]uint8, local131)
4133         {
4134                 _, err := io.ReadFull(r, (local130)[:])
4135                 chk(err)
4136         }
4137         ((*(*(struct {
4138                 ID      SoundID
4139                 Name    string
4140                 Gain    float32
4141                 SrcType SoundSrcType
4142                 Pos
4143                 SrcAOID   AOID
4144                 Loop      bool
4145                 Fade      float32
4146                 Pitch     float32
4147                 Ephemeral bool
4148         }))(obj)).Name) = string(local130)
4149         {
4150                 p := &(*(*(struct {
4151                         ID      SoundID
4152                         Name    string
4153                         Gain    float32
4154                         SrcType SoundSrcType
4155                         Pos
4156                         SrcAOID   AOID
4157                         Loop      bool
4158                         Fade      float32
4159                         Pitch     float32
4160                         Ephemeral bool
4161                 }))(obj)).Gain
4162                 *p = math.Float32frombits(read32(r))
4163         }
4164         if err := pcall(func() {
4165                 ((*(*(struct {
4166                         ID      SoundID
4167                         Name    string
4168                         Gain    float32
4169                         SrcType SoundSrcType
4170                         Pos
4171                         SrcAOID   AOID
4172                         Loop      bool
4173                         Fade      float32
4174                         Pitch     float32
4175                         Ephemeral bool
4176                 }))(obj)).SrcType).deserialize(r)
4177         }); err != nil {
4178                 if err == io.EOF {
4179                         chk(io.EOF)
4180                 }
4181                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundSrcType", err))
4182         }
4183         if err := pcall(func() {
4184                 ((*(*(struct {
4185                         ID      SoundID
4186                         Name    string
4187                         Gain    float32
4188                         SrcType SoundSrcType
4189                         Pos
4190                         SrcAOID   AOID
4191                         Loop      bool
4192                         Fade      float32
4193                         Pitch     float32
4194                         Ephemeral bool
4195                 }))(obj)).Pos).deserialize(r)
4196         }); err != nil {
4197                 if err == io.EOF {
4198                         chk(io.EOF)
4199                 }
4200                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
4201         }
4202         if err := pcall(func() {
4203                 ((*(*(struct {
4204                         ID      SoundID
4205                         Name    string
4206                         Gain    float32
4207                         SrcType SoundSrcType
4208                         Pos
4209                         SrcAOID   AOID
4210                         Loop      bool
4211                         Fade      float32
4212                         Pitch     float32
4213                         Ephemeral bool
4214                 }))(obj)).SrcAOID).deserialize(r)
4215         }); err != nil {
4216                 if err == io.EOF {
4217                         chk(io.EOF)
4218                 }
4219                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
4220         }
4221         {
4222                 p := &(*(*(struct {
4223                         ID      SoundID
4224                         Name    string
4225                         Gain    float32
4226                         SrcType SoundSrcType
4227                         Pos
4228                         SrcAOID   AOID
4229                         Loop      bool
4230                         Fade      float32
4231                         Pitch     float32
4232                         Ephemeral bool
4233                 }))(obj)).Loop
4234                 switch n := read8(r); n {
4235                 case 0:
4236                         *p = false
4237                 case 1:
4238                         *p = true
4239                 default:
4240                         chk(fmt.Errorf("invalid bool: %d", n))
4241                 }
4242         }
4243         {
4244                 p := &(*(*(struct {
4245                         ID      SoundID
4246                         Name    string
4247                         Gain    float32
4248                         SrcType SoundSrcType
4249                         Pos
4250                         SrcAOID   AOID
4251                         Loop      bool
4252                         Fade      float32
4253                         Pitch     float32
4254                         Ephemeral bool
4255                 }))(obj)).Fade
4256                 *p = math.Float32frombits(read32(r))
4257         }
4258         {
4259                 p := &(*(*(struct {
4260                         ID      SoundID
4261                         Name    string
4262                         Gain    float32
4263                         SrcType SoundSrcType
4264                         Pos
4265                         SrcAOID   AOID
4266                         Loop      bool
4267                         Fade      float32
4268                         Pitch     float32
4269                         Ephemeral bool
4270                 }))(obj)).Pitch
4271                 *p = math.Float32frombits(read32(r))
4272         }
4273         {
4274                 p := &(*(*(struct {
4275                         ID      SoundID
4276                         Name    string
4277                         Gain    float32
4278                         SrcType SoundSrcType
4279                         Pos
4280                         SrcAOID   AOID
4281                         Loop      bool
4282                         Fade      float32
4283                         Pitch     float32
4284                         Ephemeral bool
4285                 }))(obj)).Ephemeral
4286                 switch n := read8(r); n {
4287                 case 0:
4288                         *p = false
4289                 case 1:
4290                         *p = true
4291                 default:
4292                         chk(fmt.Errorf("invalid bool: %d", n))
4293                 }
4294         }
4295 }
4296
4297 func (obj *ToCltStopSound) serialize(w io.Writer) {
4298         if err := pcall(func() {
4299                 ((*(*(struct {
4300                         ID SoundID
4301                 }))(obj)).ID).serialize(w)
4302         }); err != nil {
4303                 if err == io.EOF {
4304                         chk(io.EOF)
4305                 }
4306                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4307         }
4308 }
4309
4310 func (obj *ToCltStopSound) deserialize(r io.Reader) {
4311         if err := pcall(func() {
4312                 ((*(*(struct {
4313                         ID SoundID
4314                 }))(obj)).ID).deserialize(r)
4315         }); err != nil {
4316                 if err == io.EOF {
4317                         chk(io.EOF)
4318                 }
4319                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
4320         }
4321 }
4322
4323 func (obj *ToCltPrivs) serialize(w io.Writer) {
4324         if len(((*(*(struct {
4325                 Privs []string
4326         }))(obj)).Privs)) > math.MaxUint16 {
4327                 chk(ErrTooLong)
4328         }
4329         {
4330                 x := uint16(len(((*(*(struct {
4331                         Privs []string
4332                 }))(obj)).Privs)))
4333                 write16(w, uint16(x))
4334         }
4335         for local132 := range (*(*(struct {
4336                 Privs []string
4337         }))(obj)).Privs {
4338                 if len(([]byte(((*(*(struct {
4339                         Privs []string
4340                 }))(obj)).Privs)[local132]))) > math.MaxUint16 {
4341                         chk(ErrTooLong)
4342                 }
4343                 {
4344                         x := uint16(len(([]byte(((*(*(struct {
4345                                 Privs []string
4346                         }))(obj)).Privs)[local132]))))
4347                         write16(w, uint16(x))
4348                 }
4349                 {
4350                         _, err := w.Write(([]byte(((*(*(struct {
4351                                 Privs []string
4352                         }))(obj)).Privs)[local132]))[:])
4353                         chk(err)
4354                 }
4355         }
4356 }
4357
4358 func (obj *ToCltPrivs) deserialize(r io.Reader) {
4359         var local133 uint16
4360         {
4361                 p := &local133
4362                 *p = read16(r)
4363         }
4364         ((*(*(struct {
4365                 Privs []string
4366         }))(obj)).Privs) = make([]string, local133)
4367         for local134 := range (*(*(struct {
4368                 Privs []string
4369         }))(obj)).Privs {
4370                 var local135 []uint8
4371                 var local136 uint16
4372                 {
4373                         p := &local136
4374                         *p = read16(r)
4375                 }
4376                 (local135) = make([]uint8, local136)
4377                 {
4378                         _, err := io.ReadFull(r, (local135)[:])
4379                         chk(err)
4380                 }
4381                 (((*(*(struct {
4382                         Privs []string
4383                 }))(obj)).Privs)[local134]) = string(local135)
4384         }
4385 }
4386
4387 func (obj *ToCltInvFormspec) serialize(w io.Writer) {
4388         if len(([]byte((*(*(struct {
4389                 //mt:len32
4390                 Formspec string
4391         }))(obj)).Formspec))) > math.MaxUint32 {
4392                 chk(ErrTooLong)
4393         }
4394         {
4395                 x := uint32(len(([]byte((*(*(struct {
4396                         //mt:len32
4397                         Formspec string
4398                 }))(obj)).Formspec))))
4399                 write32(w, uint32(x))
4400         }
4401         {
4402                 _, err := w.Write(([]byte((*(*(struct {
4403                         //mt:len32
4404                         Formspec string
4405                 }))(obj)).Formspec))[:])
4406                 chk(err)
4407         }
4408 }
4409
4410 func (obj *ToCltInvFormspec) deserialize(r io.Reader) {
4411         var local137 []uint8
4412         var local138 uint32
4413         {
4414                 p := &local138
4415                 *p = read32(r)
4416         }
4417         (local137) = make([]uint8, local138)
4418         {
4419                 _, err := io.ReadFull(r, (local137)[:])
4420                 chk(err)
4421         }
4422         ((*(*(struct {
4423                 //mt:len32
4424                 Formspec string
4425         }))(obj)).Formspec) = string(local137)
4426 }
4427
4428 func (obj *ToCltDetachedInv) serialize(w io.Writer) {
4429         if len(([]byte((*(*(struct {
4430                 Name string
4431                 Keep bool
4432                 Len  uint16 // deprecated
4433
4434                 //mt:raw
4435                 Inv string
4436         }))(obj)).Name))) > math.MaxUint16 {
4437                 chk(ErrTooLong)
4438         }
4439         {
4440                 x := uint16(len(([]byte((*(*(struct {
4441                         Name string
4442                         Keep bool
4443                         Len  uint16 // deprecated
4444
4445                         //mt:raw
4446                         Inv string
4447                 }))(obj)).Name))))
4448                 write16(w, uint16(x))
4449         }
4450         {
4451                 _, err := w.Write(([]byte((*(*(struct {
4452                         Name string
4453                         Keep bool
4454                         Len  uint16 // deprecated
4455
4456                         //mt:raw
4457                         Inv string
4458                 }))(obj)).Name))[:])
4459                 chk(err)
4460         }
4461         {
4462                 x := (*(*(struct {
4463                         Name string
4464                         Keep bool
4465                         Len  uint16 // deprecated
4466
4467                         //mt:raw
4468                         Inv string
4469                 }))(obj)).Keep
4470                 if x {
4471                         write8(w, 1)
4472                 } else {
4473                         write8(w, 0)
4474                 }
4475         }
4476         {
4477                 x := (*(*(struct {
4478                         Name string
4479                         Keep bool
4480                         Len  uint16 // deprecated
4481
4482                         //mt:raw
4483                         Inv string
4484                 }))(obj)).Len
4485                 write16(w, uint16(x))
4486         }
4487         {
4488                 _, err := w.Write(([]byte((*(*(struct {
4489                         Name string
4490                         Keep bool
4491                         Len  uint16 // deprecated
4492
4493                         //mt:raw
4494                         Inv string
4495                 }))(obj)).Inv))[:])
4496                 chk(err)
4497         }
4498 }
4499
4500 func (obj *ToCltDetachedInv) deserialize(r io.Reader) {
4501         var local139 []uint8
4502         var local140 uint16
4503         {
4504                 p := &local140
4505                 *p = read16(r)
4506         }
4507         (local139) = make([]uint8, local140)
4508         {
4509                 _, err := io.ReadFull(r, (local139)[:])
4510                 chk(err)
4511         }
4512         ((*(*(struct {
4513                 Name string
4514                 Keep bool
4515                 Len  uint16 // deprecated
4516
4517                 //mt:raw
4518                 Inv string
4519         }))(obj)).Name) = string(local139)
4520         {
4521                 p := &(*(*(struct {
4522                         Name string
4523                         Keep bool
4524                         Len  uint16 // deprecated
4525
4526                         //mt:raw
4527                         Inv string
4528                 }))(obj)).Keep
4529                 switch n := read8(r); n {
4530                 case 0:
4531                         *p = false
4532                 case 1:
4533                         *p = true
4534                 default:
4535                         chk(fmt.Errorf("invalid bool: %d", n))
4536                 }
4537         }
4538         {
4539                 p := &(*(*(struct {
4540                         Name string
4541                         Keep bool
4542                         Len  uint16 // deprecated
4543
4544                         //mt:raw
4545                         Inv string
4546                 }))(obj)).Len
4547                 *p = read16(r)
4548         }
4549         var local141 []uint8
4550         {
4551                 var err error
4552                 (local141), err = io.ReadAll(r)
4553                 chk(err)
4554         }
4555         ((*(*(struct {
4556                 Name string
4557                 Keep bool
4558                 Len  uint16 // deprecated
4559
4560                 //mt:raw
4561                 Inv string
4562         }))(obj)).Inv) = string(local141)
4563 }
4564
4565 func (obj *ToCltShowFormspec) serialize(w io.Writer) {
4566         if len(([]byte((*(*(struct {
4567                 //mt:len32
4568                 Formspec string
4569
4570                 Formname string
4571         }))(obj)).Formspec))) > math.MaxUint32 {
4572                 chk(ErrTooLong)
4573         }
4574         {
4575                 x := uint32(len(([]byte((*(*(struct {
4576                         //mt:len32
4577                         Formspec string
4578
4579                         Formname string
4580                 }))(obj)).Formspec))))
4581                 write32(w, uint32(x))
4582         }
4583         {
4584                 _, err := w.Write(([]byte((*(*(struct {
4585                         //mt:len32
4586                         Formspec string
4587
4588                         Formname string
4589                 }))(obj)).Formspec))[:])
4590                 chk(err)
4591         }
4592         if len(([]byte((*(*(struct {
4593                 //mt:len32
4594                 Formspec string
4595
4596                 Formname string
4597         }))(obj)).Formname))) > math.MaxUint16 {
4598                 chk(ErrTooLong)
4599         }
4600         {
4601                 x := uint16(len(([]byte((*(*(struct {
4602                         //mt:len32
4603                         Formspec string
4604
4605                         Formname string
4606                 }))(obj)).Formname))))
4607                 write16(w, uint16(x))
4608         }
4609         {
4610                 _, err := w.Write(([]byte((*(*(struct {
4611                         //mt:len32
4612                         Formspec string
4613
4614                         Formname string
4615                 }))(obj)).Formname))[:])
4616                 chk(err)
4617         }
4618 }
4619
4620 func (obj *ToCltShowFormspec) deserialize(r io.Reader) {
4621         var local142 []uint8
4622         var local143 uint32
4623         {
4624                 p := &local143
4625                 *p = read32(r)
4626         }
4627         (local142) = make([]uint8, local143)
4628         {
4629                 _, err := io.ReadFull(r, (local142)[:])
4630                 chk(err)
4631         }
4632         ((*(*(struct {
4633                 //mt:len32
4634                 Formspec string
4635
4636                 Formname string
4637         }))(obj)).Formspec) = string(local142)
4638         var local144 []uint8
4639         var local145 uint16
4640         {
4641                 p := &local145
4642                 *p = read16(r)
4643         }
4644         (local144) = make([]uint8, local145)
4645         {
4646                 _, err := io.ReadFull(r, (local144)[:])
4647                 chk(err)
4648         }
4649         ((*(*(struct {
4650                 //mt:len32
4651                 Formspec string
4652
4653                 Formname string
4654         }))(obj)).Formname) = string(local144)
4655 }
4656
4657 func (obj *ToCltMovement) serialize(w io.Writer) {
4658         {
4659                 x := (*(*(struct {
4660                         DefaultAccel, AirAccel, FastAccel,
4661                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4662                         Fluidity, Smoothing, Sink,
4663                         Gravity float32
4664                 }))(obj)).DefaultAccel
4665                 write32(w, math.Float32bits(x))
4666         }
4667         {
4668                 x := (*(*(struct {
4669                         DefaultAccel, AirAccel, FastAccel,
4670                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4671                         Fluidity, Smoothing, Sink,
4672                         Gravity float32
4673                 }))(obj)).AirAccel
4674                 write32(w, math.Float32bits(x))
4675         }
4676         {
4677                 x := (*(*(struct {
4678                         DefaultAccel, AirAccel, FastAccel,
4679                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4680                         Fluidity, Smoothing, Sink,
4681                         Gravity float32
4682                 }))(obj)).FastAccel
4683                 write32(w, math.Float32bits(x))
4684         }
4685         {
4686                 x := (*(*(struct {
4687                         DefaultAccel, AirAccel, FastAccel,
4688                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4689                         Fluidity, Smoothing, Sink,
4690                         Gravity float32
4691                 }))(obj)).WalkSpeed
4692                 write32(w, math.Float32bits(x))
4693         }
4694         {
4695                 x := (*(*(struct {
4696                         DefaultAccel, AirAccel, FastAccel,
4697                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4698                         Fluidity, Smoothing, Sink,
4699                         Gravity float32
4700                 }))(obj)).CrouchSpeed
4701                 write32(w, math.Float32bits(x))
4702         }
4703         {
4704                 x := (*(*(struct {
4705                         DefaultAccel, AirAccel, FastAccel,
4706                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4707                         Fluidity, Smoothing, Sink,
4708                         Gravity float32
4709                 }))(obj)).FastSpeed
4710                 write32(w, math.Float32bits(x))
4711         }
4712         {
4713                 x := (*(*(struct {
4714                         DefaultAccel, AirAccel, FastAccel,
4715                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4716                         Fluidity, Smoothing, Sink,
4717                         Gravity float32
4718                 }))(obj)).ClimbSpeed
4719                 write32(w, math.Float32bits(x))
4720         }
4721         {
4722                 x := (*(*(struct {
4723                         DefaultAccel, AirAccel, FastAccel,
4724                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4725                         Fluidity, Smoothing, Sink,
4726                         Gravity float32
4727                 }))(obj)).JumpSpeed
4728                 write32(w, math.Float32bits(x))
4729         }
4730         {
4731                 x := (*(*(struct {
4732                         DefaultAccel, AirAccel, FastAccel,
4733                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4734                         Fluidity, Smoothing, Sink,
4735                         Gravity float32
4736                 }))(obj)).Fluidity
4737                 write32(w, math.Float32bits(x))
4738         }
4739         {
4740                 x := (*(*(struct {
4741                         DefaultAccel, AirAccel, FastAccel,
4742                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4743                         Fluidity, Smoothing, Sink,
4744                         Gravity float32
4745                 }))(obj)).Smoothing
4746                 write32(w, math.Float32bits(x))
4747         }
4748         {
4749                 x := (*(*(struct {
4750                         DefaultAccel, AirAccel, FastAccel,
4751                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4752                         Fluidity, Smoothing, Sink,
4753                         Gravity float32
4754                 }))(obj)).Sink
4755                 write32(w, math.Float32bits(x))
4756         }
4757         {
4758                 x := (*(*(struct {
4759                         DefaultAccel, AirAccel, FastAccel,
4760                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4761                         Fluidity, Smoothing, Sink,
4762                         Gravity float32
4763                 }))(obj)).Gravity
4764                 write32(w, math.Float32bits(x))
4765         }
4766 }
4767
4768 func (obj *ToCltMovement) deserialize(r io.Reader) {
4769         {
4770                 p := &(*(*(struct {
4771                         DefaultAccel, AirAccel, FastAccel,
4772                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4773                         Fluidity, Smoothing, Sink,
4774                         Gravity float32
4775                 }))(obj)).DefaultAccel
4776                 *p = math.Float32frombits(read32(r))
4777         }
4778         {
4779                 p := &(*(*(struct {
4780                         DefaultAccel, AirAccel, FastAccel,
4781                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4782                         Fluidity, Smoothing, Sink,
4783                         Gravity float32
4784                 }))(obj)).AirAccel
4785                 *p = math.Float32frombits(read32(r))
4786         }
4787         {
4788                 p := &(*(*(struct {
4789                         DefaultAccel, AirAccel, FastAccel,
4790                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4791                         Fluidity, Smoothing, Sink,
4792                         Gravity float32
4793                 }))(obj)).FastAccel
4794                 *p = math.Float32frombits(read32(r))
4795         }
4796         {
4797                 p := &(*(*(struct {
4798                         DefaultAccel, AirAccel, FastAccel,
4799                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4800                         Fluidity, Smoothing, Sink,
4801                         Gravity float32
4802                 }))(obj)).WalkSpeed
4803                 *p = math.Float32frombits(read32(r))
4804         }
4805         {
4806                 p := &(*(*(struct {
4807                         DefaultAccel, AirAccel, FastAccel,
4808                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4809                         Fluidity, Smoothing, Sink,
4810                         Gravity float32
4811                 }))(obj)).CrouchSpeed
4812                 *p = math.Float32frombits(read32(r))
4813         }
4814         {
4815                 p := &(*(*(struct {
4816                         DefaultAccel, AirAccel, FastAccel,
4817                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4818                         Fluidity, Smoothing, Sink,
4819                         Gravity float32
4820                 }))(obj)).FastSpeed
4821                 *p = math.Float32frombits(read32(r))
4822         }
4823         {
4824                 p := &(*(*(struct {
4825                         DefaultAccel, AirAccel, FastAccel,
4826                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4827                         Fluidity, Smoothing, Sink,
4828                         Gravity float32
4829                 }))(obj)).ClimbSpeed
4830                 *p = math.Float32frombits(read32(r))
4831         }
4832         {
4833                 p := &(*(*(struct {
4834                         DefaultAccel, AirAccel, FastAccel,
4835                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4836                         Fluidity, Smoothing, Sink,
4837                         Gravity float32
4838                 }))(obj)).JumpSpeed
4839                 *p = math.Float32frombits(read32(r))
4840         }
4841         {
4842                 p := &(*(*(struct {
4843                         DefaultAccel, AirAccel, FastAccel,
4844                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4845                         Fluidity, Smoothing, Sink,
4846                         Gravity float32
4847                 }))(obj)).Fluidity
4848                 *p = math.Float32frombits(read32(r))
4849         }
4850         {
4851                 p := &(*(*(struct {
4852                         DefaultAccel, AirAccel, FastAccel,
4853                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4854                         Fluidity, Smoothing, Sink,
4855                         Gravity float32
4856                 }))(obj)).Smoothing
4857                 *p = math.Float32frombits(read32(r))
4858         }
4859         {
4860                 p := &(*(*(struct {
4861                         DefaultAccel, AirAccel, FastAccel,
4862                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4863                         Fluidity, Smoothing, Sink,
4864                         Gravity float32
4865                 }))(obj)).Sink
4866                 *p = math.Float32frombits(read32(r))
4867         }
4868         {
4869                 p := &(*(*(struct {
4870                         DefaultAccel, AirAccel, FastAccel,
4871                         WalkSpeed, CrouchSpeed, FastSpeed, ClimbSpeed, JumpSpeed,
4872                         Fluidity, Smoothing, Sink,
4873                         Gravity float32
4874                 }))(obj)).Gravity
4875                 *p = math.Float32frombits(read32(r))
4876         }
4877 }
4878
4879 func (obj *ToCltSpawnParticle) serialize(w io.Writer) {
4880         for local146 := range (*(*(struct {
4881                 Pos, Vel, Acc  [3]float32
4882                 ExpirationTime float32 // in seconds.
4883                 Size           float32
4884                 Collide        bool
4885
4886                 //mt:len32
4887                 Texture
4888
4889                 Vertical    bool
4890                 CollisionRm bool
4891                 AnimParams  TileAnim
4892                 Glow        uint8
4893                 AOCollision bool
4894                 NodeParam0  Content
4895                 NodeParam2  uint8
4896                 NodeTile    uint8
4897         }))(obj)).Pos {
4898                 {
4899                         x := ((*(*(struct {
4900                                 Pos, Vel, Acc  [3]float32
4901                                 ExpirationTime float32 // in seconds.
4902                                 Size           float32
4903                                 Collide        bool
4904
4905                                 //mt:len32
4906                                 Texture
4907
4908                                 Vertical    bool
4909                                 CollisionRm bool
4910                                 AnimParams  TileAnim
4911                                 Glow        uint8
4912                                 AOCollision bool
4913                                 NodeParam0  Content
4914                                 NodeParam2  uint8
4915                                 NodeTile    uint8
4916                         }))(obj)).Pos)[local146]
4917                         write32(w, math.Float32bits(x))
4918                 }
4919         }
4920         for local147 := range (*(*(struct {
4921                 Pos, Vel, Acc  [3]float32
4922                 ExpirationTime float32 // in seconds.
4923                 Size           float32
4924                 Collide        bool
4925
4926                 //mt:len32
4927                 Texture
4928
4929                 Vertical    bool
4930                 CollisionRm bool
4931                 AnimParams  TileAnim
4932                 Glow        uint8
4933                 AOCollision bool
4934                 NodeParam0  Content
4935                 NodeParam2  uint8
4936                 NodeTile    uint8
4937         }))(obj)).Vel {
4938                 {
4939                         x := ((*(*(struct {
4940                                 Pos, Vel, Acc  [3]float32
4941                                 ExpirationTime float32 // in seconds.
4942                                 Size           float32
4943                                 Collide        bool
4944
4945                                 //mt:len32
4946                                 Texture
4947
4948                                 Vertical    bool
4949                                 CollisionRm bool
4950                                 AnimParams  TileAnim
4951                                 Glow        uint8
4952                                 AOCollision bool
4953                                 NodeParam0  Content
4954                                 NodeParam2  uint8
4955                                 NodeTile    uint8
4956                         }))(obj)).Vel)[local147]
4957                         write32(w, math.Float32bits(x))
4958                 }
4959         }
4960         for local148 := range (*(*(struct {
4961                 Pos, Vel, Acc  [3]float32
4962                 ExpirationTime float32 // in seconds.
4963                 Size           float32
4964                 Collide        bool
4965
4966                 //mt:len32
4967                 Texture
4968
4969                 Vertical    bool
4970                 CollisionRm bool
4971                 AnimParams  TileAnim
4972                 Glow        uint8
4973                 AOCollision bool
4974                 NodeParam0  Content
4975                 NodeParam2  uint8
4976                 NodeTile    uint8
4977         }))(obj)).Acc {
4978                 {
4979                         x := ((*(*(struct {
4980                                 Pos, Vel, Acc  [3]float32
4981                                 ExpirationTime float32 // in seconds.
4982                                 Size           float32
4983                                 Collide        bool
4984
4985                                 //mt:len32
4986                                 Texture
4987
4988                                 Vertical    bool
4989                                 CollisionRm bool
4990                                 AnimParams  TileAnim
4991                                 Glow        uint8
4992                                 AOCollision bool
4993                                 NodeParam0  Content
4994                                 NodeParam2  uint8
4995                                 NodeTile    uint8
4996                         }))(obj)).Acc)[local148]
4997                         write32(w, math.Float32bits(x))
4998                 }
4999         }
5000         {
5001                 x := (*(*(struct {
5002                         Pos, Vel, Acc  [3]float32
5003                         ExpirationTime float32 // in seconds.
5004                         Size           float32
5005                         Collide        bool
5006
5007                         //mt:len32
5008                         Texture
5009
5010                         Vertical    bool
5011                         CollisionRm bool
5012                         AnimParams  TileAnim
5013                         Glow        uint8
5014                         AOCollision bool
5015                         NodeParam0  Content
5016                         NodeParam2  uint8
5017                         NodeTile    uint8
5018                 }))(obj)).ExpirationTime
5019                 write32(w, math.Float32bits(x))
5020         }
5021         {
5022                 x := (*(*(struct {
5023                         Pos, Vel, Acc  [3]float32
5024                         ExpirationTime float32 // in seconds.
5025                         Size           float32
5026                         Collide        bool
5027
5028                         //mt:len32
5029                         Texture
5030
5031                         Vertical    bool
5032                         CollisionRm bool
5033                         AnimParams  TileAnim
5034                         Glow        uint8
5035                         AOCollision bool
5036                         NodeParam0  Content
5037                         NodeParam2  uint8
5038                         NodeTile    uint8
5039                 }))(obj)).Size
5040                 write32(w, math.Float32bits(x))
5041         }
5042         {
5043                 x := (*(*(struct {
5044                         Pos, Vel, Acc  [3]float32
5045                         ExpirationTime float32 // in seconds.
5046                         Size           float32
5047                         Collide        bool
5048
5049                         //mt:len32
5050                         Texture
5051
5052                         Vertical    bool
5053                         CollisionRm bool
5054                         AnimParams  TileAnim
5055                         Glow        uint8
5056                         AOCollision bool
5057                         NodeParam0  Content
5058                         NodeParam2  uint8
5059                         NodeTile    uint8
5060                 }))(obj)).Collide
5061                 if x {
5062                         write8(w, 1)
5063                 } else {
5064                         write8(w, 0)
5065                 }
5066         }
5067         if len(([]byte(*(*string)(&((*(*(struct {
5068                 Pos, Vel, Acc  [3]float32
5069                 ExpirationTime float32 // in seconds.
5070                 Size           float32
5071                 Collide        bool
5072
5073                 //mt:len32
5074                 Texture
5075
5076                 Vertical    bool
5077                 CollisionRm bool
5078                 AnimParams  TileAnim
5079                 Glow        uint8
5080                 AOCollision bool
5081                 NodeParam0  Content
5082                 NodeParam2  uint8
5083                 NodeTile    uint8
5084         }))(obj)).Texture))))) > math.MaxUint32 {
5085                 chk(ErrTooLong)
5086         }
5087         {
5088                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
5089                         Pos, Vel, Acc  [3]float32
5090                         ExpirationTime float32 // in seconds.
5091                         Size           float32
5092                         Collide        bool
5093
5094                         //mt:len32
5095                         Texture
5096
5097                         Vertical    bool
5098                         CollisionRm bool
5099                         AnimParams  TileAnim
5100                         Glow        uint8
5101                         AOCollision bool
5102                         NodeParam0  Content
5103                         NodeParam2  uint8
5104                         NodeTile    uint8
5105                 }))(obj)).Texture))))))
5106                 write32(w, uint32(x))
5107         }
5108         {
5109                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
5110                         Pos, Vel, Acc  [3]float32
5111                         ExpirationTime float32 // in seconds.
5112                         Size           float32
5113                         Collide        bool
5114
5115                         //mt:len32
5116                         Texture
5117
5118                         Vertical    bool
5119                         CollisionRm bool
5120                         AnimParams  TileAnim
5121                         Glow        uint8
5122                         AOCollision bool
5123                         NodeParam0  Content
5124                         NodeParam2  uint8
5125                         NodeTile    uint8
5126                 }))(obj)).Texture))))[:])
5127                 chk(err)
5128         }
5129         {
5130                 x := (*(*(struct {
5131                         Pos, Vel, Acc  [3]float32
5132                         ExpirationTime float32 // in seconds.
5133                         Size           float32
5134                         Collide        bool
5135
5136                         //mt:len32
5137                         Texture
5138
5139                         Vertical    bool
5140                         CollisionRm bool
5141                         AnimParams  TileAnim
5142                         Glow        uint8
5143                         AOCollision bool
5144                         NodeParam0  Content
5145                         NodeParam2  uint8
5146                         NodeTile    uint8
5147                 }))(obj)).Vertical
5148                 if x {
5149                         write8(w, 1)
5150                 } else {
5151                         write8(w, 0)
5152                 }
5153         }
5154         {
5155                 x := (*(*(struct {
5156                         Pos, Vel, Acc  [3]float32
5157                         ExpirationTime float32 // in seconds.
5158                         Size           float32
5159                         Collide        bool
5160
5161                         //mt:len32
5162                         Texture
5163
5164                         Vertical    bool
5165                         CollisionRm bool
5166                         AnimParams  TileAnim
5167                         Glow        uint8
5168                         AOCollision bool
5169                         NodeParam0  Content
5170                         NodeParam2  uint8
5171                         NodeTile    uint8
5172                 }))(obj)).CollisionRm
5173                 if x {
5174                         write8(w, 1)
5175                 } else {
5176                         write8(w, 0)
5177                 }
5178         }
5179         if err := pcall(func() {
5180                 ((*(*(struct {
5181                         Pos, Vel, Acc  [3]float32
5182                         ExpirationTime float32 // in seconds.
5183                         Size           float32
5184                         Collide        bool
5185
5186                         //mt:len32
5187                         Texture
5188
5189                         Vertical    bool
5190                         CollisionRm bool
5191                         AnimParams  TileAnim
5192                         Glow        uint8
5193                         AOCollision bool
5194                         NodeParam0  Content
5195                         NodeParam2  uint8
5196                         NodeTile    uint8
5197                 }))(obj)).AnimParams).serialize(w)
5198         }); err != nil {
5199                 if err == io.EOF {
5200                         chk(io.EOF)
5201                 }
5202                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
5203         }
5204         {
5205                 x := (*(*(struct {
5206                         Pos, Vel, Acc  [3]float32
5207                         ExpirationTime float32 // in seconds.
5208                         Size           float32
5209                         Collide        bool
5210
5211                         //mt:len32
5212                         Texture
5213
5214                         Vertical    bool
5215                         CollisionRm bool
5216                         AnimParams  TileAnim
5217                         Glow        uint8
5218                         AOCollision bool
5219                         NodeParam0  Content
5220                         NodeParam2  uint8
5221                         NodeTile    uint8
5222                 }))(obj)).Glow
5223                 write8(w, uint8(x))
5224         }
5225         {
5226                 x := (*(*(struct {
5227                         Pos, Vel, Acc  [3]float32
5228                         ExpirationTime float32 // in seconds.
5229                         Size           float32
5230                         Collide        bool
5231
5232                         //mt:len32
5233                         Texture
5234
5235                         Vertical    bool
5236                         CollisionRm bool
5237                         AnimParams  TileAnim
5238                         Glow        uint8
5239                         AOCollision bool
5240                         NodeParam0  Content
5241                         NodeParam2  uint8
5242                         NodeTile    uint8
5243                 }))(obj)).AOCollision
5244                 if x {
5245                         write8(w, 1)
5246                 } else {
5247                         write8(w, 0)
5248                 }
5249         }
5250         if err := pcall(func() {
5251                 ((*(*(struct {
5252                         Pos, Vel, Acc  [3]float32
5253                         ExpirationTime float32 // in seconds.
5254                         Size           float32
5255                         Collide        bool
5256
5257                         //mt:len32
5258                         Texture
5259
5260                         Vertical    bool
5261                         CollisionRm bool
5262                         AnimParams  TileAnim
5263                         Glow        uint8
5264                         AOCollision bool
5265                         NodeParam0  Content
5266                         NodeParam2  uint8
5267                         NodeTile    uint8
5268                 }))(obj)).NodeParam0).serialize(w)
5269         }); err != nil {
5270                 if err == io.EOF {
5271                         chk(io.EOF)
5272                 }
5273                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
5274         }
5275         {
5276                 x := (*(*(struct {
5277                         Pos, Vel, Acc  [3]float32
5278                         ExpirationTime float32 // in seconds.
5279                         Size           float32
5280                         Collide        bool
5281
5282                         //mt:len32
5283                         Texture
5284
5285                         Vertical    bool
5286                         CollisionRm bool
5287                         AnimParams  TileAnim
5288                         Glow        uint8
5289                         AOCollision bool
5290                         NodeParam0  Content
5291                         NodeParam2  uint8
5292                         NodeTile    uint8
5293                 }))(obj)).NodeParam2
5294                 write8(w, uint8(x))
5295         }
5296         {
5297                 x := (*(*(struct {
5298                         Pos, Vel, Acc  [3]float32
5299                         ExpirationTime float32 // in seconds.
5300                         Size           float32
5301                         Collide        bool
5302
5303                         //mt:len32
5304                         Texture
5305
5306                         Vertical    bool
5307                         CollisionRm bool
5308                         AnimParams  TileAnim
5309                         Glow        uint8
5310                         AOCollision bool
5311                         NodeParam0  Content
5312                         NodeParam2  uint8
5313                         NodeTile    uint8
5314                 }))(obj)).NodeTile
5315                 write8(w, uint8(x))
5316         }
5317 }
5318
5319 func (obj *ToCltSpawnParticle) deserialize(r io.Reader) {
5320         for local149 := range (*(*(struct {
5321                 Pos, Vel, Acc  [3]float32
5322                 ExpirationTime float32 // in seconds.
5323                 Size           float32
5324                 Collide        bool
5325
5326                 //mt:len32
5327                 Texture
5328
5329                 Vertical    bool
5330                 CollisionRm bool
5331                 AnimParams  TileAnim
5332                 Glow        uint8
5333                 AOCollision bool
5334                 NodeParam0  Content
5335                 NodeParam2  uint8
5336                 NodeTile    uint8
5337         }))(obj)).Pos {
5338                 {
5339                         p := &((*(*(struct {
5340                                 Pos, Vel, Acc  [3]float32
5341                                 ExpirationTime float32 // in seconds.
5342                                 Size           float32
5343                                 Collide        bool
5344
5345                                 //mt:len32
5346                                 Texture
5347
5348                                 Vertical    bool
5349                                 CollisionRm bool
5350                                 AnimParams  TileAnim
5351                                 Glow        uint8
5352                                 AOCollision bool
5353                                 NodeParam0  Content
5354                                 NodeParam2  uint8
5355                                 NodeTile    uint8
5356                         }))(obj)).Pos)[local149]
5357                         *p = math.Float32frombits(read32(r))
5358                 }
5359         }
5360         for local150 := range (*(*(struct {
5361                 Pos, Vel, Acc  [3]float32
5362                 ExpirationTime float32 // in seconds.
5363                 Size           float32
5364                 Collide        bool
5365
5366                 //mt:len32
5367                 Texture
5368
5369                 Vertical    bool
5370                 CollisionRm bool
5371                 AnimParams  TileAnim
5372                 Glow        uint8
5373                 AOCollision bool
5374                 NodeParam0  Content
5375                 NodeParam2  uint8
5376                 NodeTile    uint8
5377         }))(obj)).Vel {
5378                 {
5379                         p := &((*(*(struct {
5380                                 Pos, Vel, Acc  [3]float32
5381                                 ExpirationTime float32 // in seconds.
5382                                 Size           float32
5383                                 Collide        bool
5384
5385                                 //mt:len32
5386                                 Texture
5387
5388                                 Vertical    bool
5389                                 CollisionRm bool
5390                                 AnimParams  TileAnim
5391                                 Glow        uint8
5392                                 AOCollision bool
5393                                 NodeParam0  Content
5394                                 NodeParam2  uint8
5395                                 NodeTile    uint8
5396                         }))(obj)).Vel)[local150]
5397                         *p = math.Float32frombits(read32(r))
5398                 }
5399         }
5400         for local151 := range (*(*(struct {
5401                 Pos, Vel, Acc  [3]float32
5402                 ExpirationTime float32 // in seconds.
5403                 Size           float32
5404                 Collide        bool
5405
5406                 //mt:len32
5407                 Texture
5408
5409                 Vertical    bool
5410                 CollisionRm bool
5411                 AnimParams  TileAnim
5412                 Glow        uint8
5413                 AOCollision bool
5414                 NodeParam0  Content
5415                 NodeParam2  uint8
5416                 NodeTile    uint8
5417         }))(obj)).Acc {
5418                 {
5419                         p := &((*(*(struct {
5420                                 Pos, Vel, Acc  [3]float32
5421                                 ExpirationTime float32 // in seconds.
5422                                 Size           float32
5423                                 Collide        bool
5424
5425                                 //mt:len32
5426                                 Texture
5427
5428                                 Vertical    bool
5429                                 CollisionRm bool
5430                                 AnimParams  TileAnim
5431                                 Glow        uint8
5432                                 AOCollision bool
5433                                 NodeParam0  Content
5434                                 NodeParam2  uint8
5435                                 NodeTile    uint8
5436                         }))(obj)).Acc)[local151]
5437                         *p = math.Float32frombits(read32(r))
5438                 }
5439         }
5440         {
5441                 p := &(*(*(struct {
5442                         Pos, Vel, Acc  [3]float32
5443                         ExpirationTime float32 // in seconds.
5444                         Size           float32
5445                         Collide        bool
5446
5447                         //mt:len32
5448                         Texture
5449
5450                         Vertical    bool
5451                         CollisionRm bool
5452                         AnimParams  TileAnim
5453                         Glow        uint8
5454                         AOCollision bool
5455                         NodeParam0  Content
5456                         NodeParam2  uint8
5457                         NodeTile    uint8
5458                 }))(obj)).ExpirationTime
5459                 *p = math.Float32frombits(read32(r))
5460         }
5461         {
5462                 p := &(*(*(struct {
5463                         Pos, Vel, Acc  [3]float32
5464                         ExpirationTime float32 // in seconds.
5465                         Size           float32
5466                         Collide        bool
5467
5468                         //mt:len32
5469                         Texture
5470
5471                         Vertical    bool
5472                         CollisionRm bool
5473                         AnimParams  TileAnim
5474                         Glow        uint8
5475                         AOCollision bool
5476                         NodeParam0  Content
5477                         NodeParam2  uint8
5478                         NodeTile    uint8
5479                 }))(obj)).Size
5480                 *p = math.Float32frombits(read32(r))
5481         }
5482         {
5483                 p := &(*(*(struct {
5484                         Pos, Vel, Acc  [3]float32
5485                         ExpirationTime float32 // in seconds.
5486                         Size           float32
5487                         Collide        bool
5488
5489                         //mt:len32
5490                         Texture
5491
5492                         Vertical    bool
5493                         CollisionRm bool
5494                         AnimParams  TileAnim
5495                         Glow        uint8
5496                         AOCollision bool
5497                         NodeParam0  Content
5498                         NodeParam2  uint8
5499                         NodeTile    uint8
5500                 }))(obj)).Collide
5501                 switch n := read8(r); n {
5502                 case 0:
5503                         *p = false
5504                 case 1:
5505                         *p = true
5506                 default:
5507                         chk(fmt.Errorf("invalid bool: %d", n))
5508                 }
5509         }
5510         var local152 []uint8
5511         var local153 uint32
5512         {
5513                 p := &local153
5514                 *p = read32(r)
5515         }
5516         (local152) = make([]uint8, local153)
5517         {
5518                 _, err := io.ReadFull(r, (local152)[:])
5519                 chk(err)
5520         }
5521         (*(*string)(&((*(*(struct {
5522                 Pos, Vel, Acc  [3]float32
5523                 ExpirationTime float32 // in seconds.
5524                 Size           float32
5525                 Collide        bool
5526
5527                 //mt:len32
5528                 Texture
5529
5530                 Vertical    bool
5531                 CollisionRm bool
5532                 AnimParams  TileAnim
5533                 Glow        uint8
5534                 AOCollision bool
5535                 NodeParam0  Content
5536                 NodeParam2  uint8
5537                 NodeTile    uint8
5538         }))(obj)).Texture))) = string(local152)
5539         {
5540                 p := &(*(*(struct {
5541                         Pos, Vel, Acc  [3]float32
5542                         ExpirationTime float32 // in seconds.
5543                         Size           float32
5544                         Collide        bool
5545
5546                         //mt:len32
5547                         Texture
5548
5549                         Vertical    bool
5550                         CollisionRm bool
5551                         AnimParams  TileAnim
5552                         Glow        uint8
5553                         AOCollision bool
5554                         NodeParam0  Content
5555                         NodeParam2  uint8
5556                         NodeTile    uint8
5557                 }))(obj)).Vertical
5558                 switch n := read8(r); n {
5559                 case 0:
5560                         *p = false
5561                 case 1:
5562                         *p = true
5563                 default:
5564                         chk(fmt.Errorf("invalid bool: %d", n))
5565                 }
5566         }
5567         {
5568                 p := &(*(*(struct {
5569                         Pos, Vel, Acc  [3]float32
5570                         ExpirationTime float32 // in seconds.
5571                         Size           float32
5572                         Collide        bool
5573
5574                         //mt:len32
5575                         Texture
5576
5577                         Vertical    bool
5578                         CollisionRm bool
5579                         AnimParams  TileAnim
5580                         Glow        uint8
5581                         AOCollision bool
5582                         NodeParam0  Content
5583                         NodeParam2  uint8
5584                         NodeTile    uint8
5585                 }))(obj)).CollisionRm
5586                 switch n := read8(r); n {
5587                 case 0:
5588                         *p = false
5589                 case 1:
5590                         *p = true
5591                 default:
5592                         chk(fmt.Errorf("invalid bool: %d", n))
5593                 }
5594         }
5595         if err := pcall(func() {
5596                 ((*(*(struct {
5597                         Pos, Vel, Acc  [3]float32
5598                         ExpirationTime float32 // in seconds.
5599                         Size           float32
5600                         Collide        bool
5601
5602                         //mt:len32
5603                         Texture
5604
5605                         Vertical    bool
5606                         CollisionRm bool
5607                         AnimParams  TileAnim
5608                         Glow        uint8
5609                         AOCollision bool
5610                         NodeParam0  Content
5611                         NodeParam2  uint8
5612                         NodeTile    uint8
5613                 }))(obj)).AnimParams).deserialize(r)
5614         }); err != nil {
5615                 if err == io.EOF {
5616                         chk(io.EOF)
5617                 }
5618                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
5619         }
5620         {
5621                 p := &(*(*(struct {
5622                         Pos, Vel, Acc  [3]float32
5623                         ExpirationTime float32 // in seconds.
5624                         Size           float32
5625                         Collide        bool
5626
5627                         //mt:len32
5628                         Texture
5629
5630                         Vertical    bool
5631                         CollisionRm bool
5632                         AnimParams  TileAnim
5633                         Glow        uint8
5634                         AOCollision bool
5635                         NodeParam0  Content
5636                         NodeParam2  uint8
5637                         NodeTile    uint8
5638                 }))(obj)).Glow
5639                 *p = read8(r)
5640         }
5641         {
5642                 p := &(*(*(struct {
5643                         Pos, Vel, Acc  [3]float32
5644                         ExpirationTime float32 // in seconds.
5645                         Size           float32
5646                         Collide        bool
5647
5648                         //mt:len32
5649                         Texture
5650
5651                         Vertical    bool
5652                         CollisionRm bool
5653                         AnimParams  TileAnim
5654                         Glow        uint8
5655                         AOCollision bool
5656                         NodeParam0  Content
5657                         NodeParam2  uint8
5658                         NodeTile    uint8
5659                 }))(obj)).AOCollision
5660                 switch n := read8(r); n {
5661                 case 0:
5662                         *p = false
5663                 case 1:
5664                         *p = true
5665                 default:
5666                         chk(fmt.Errorf("invalid bool: %d", n))
5667                 }
5668         }
5669         if err := pcall(func() {
5670                 ((*(*(struct {
5671                         Pos, Vel, Acc  [3]float32
5672                         ExpirationTime float32 // in seconds.
5673                         Size           float32
5674                         Collide        bool
5675
5676                         //mt:len32
5677                         Texture
5678
5679                         Vertical    bool
5680                         CollisionRm bool
5681                         AnimParams  TileAnim
5682                         Glow        uint8
5683                         AOCollision bool
5684                         NodeParam0  Content
5685                         NodeParam2  uint8
5686                         NodeTile    uint8
5687                 }))(obj)).NodeParam0).deserialize(r)
5688         }); err != nil {
5689                 if err == io.EOF {
5690                         chk(io.EOF)
5691                 }
5692                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
5693         }
5694         {
5695                 p := &(*(*(struct {
5696                         Pos, Vel, Acc  [3]float32
5697                         ExpirationTime float32 // in seconds.
5698                         Size           float32
5699                         Collide        bool
5700
5701                         //mt:len32
5702                         Texture
5703
5704                         Vertical    bool
5705                         CollisionRm bool
5706                         AnimParams  TileAnim
5707                         Glow        uint8
5708                         AOCollision bool
5709                         NodeParam0  Content
5710                         NodeParam2  uint8
5711                         NodeTile    uint8
5712                 }))(obj)).NodeParam2
5713                 *p = read8(r)
5714         }
5715         {
5716                 p := &(*(*(struct {
5717                         Pos, Vel, Acc  [3]float32
5718                         ExpirationTime float32 // in seconds.
5719                         Size           float32
5720                         Collide        bool
5721
5722                         //mt:len32
5723                         Texture
5724
5725                         Vertical    bool
5726                         CollisionRm bool
5727                         AnimParams  TileAnim
5728                         Glow        uint8
5729                         AOCollision bool
5730                         NodeParam0  Content
5731                         NodeParam2  uint8
5732                         NodeTile    uint8
5733                 }))(obj)).NodeTile
5734                 *p = read8(r)
5735         }
5736 }
5737
5738 func (obj *ToCltAddParticleSpawner) serialize(w io.Writer) {
5739         {
5740                 x := (*(*(struct {
5741                         Amount         uint16
5742                         Duration       float32
5743                         Pos, Vel, Acc  [2][3]float32
5744                         ExpirationTime [2]float32 // in seconds.
5745                         Size           [2]float32
5746                         Collide        bool
5747
5748                         //mt:len32
5749                         Texture
5750
5751                         ID           ParticleSpawnerID
5752                         Vertical     bool
5753                         CollisionRm  bool
5754                         AttachedAOID AOID
5755                         AnimParams   TileAnim
5756                         Glow         uint8
5757                         AOCollision  bool
5758                         NodeParam0   Content
5759                         NodeParam2   uint8
5760                         NodeTile     uint8
5761                 }))(obj)).Amount
5762                 write16(w, uint16(x))
5763         }
5764         {
5765                 x := (*(*(struct {
5766                         Amount         uint16
5767                         Duration       float32
5768                         Pos, Vel, Acc  [2][3]float32
5769                         ExpirationTime [2]float32 // in seconds.
5770                         Size           [2]float32
5771                         Collide        bool
5772
5773                         //mt:len32
5774                         Texture
5775
5776                         ID           ParticleSpawnerID
5777                         Vertical     bool
5778                         CollisionRm  bool
5779                         AttachedAOID AOID
5780                         AnimParams   TileAnim
5781                         Glow         uint8
5782                         AOCollision  bool
5783                         NodeParam0   Content
5784                         NodeParam2   uint8
5785                         NodeTile     uint8
5786                 }))(obj)).Duration
5787                 write32(w, math.Float32bits(x))
5788         }
5789         for local154 := range (*(*(struct {
5790                 Amount         uint16
5791                 Duration       float32
5792                 Pos, Vel, Acc  [2][3]float32
5793                 ExpirationTime [2]float32 // in seconds.
5794                 Size           [2]float32
5795                 Collide        bool
5796
5797                 //mt:len32
5798                 Texture
5799
5800                 ID           ParticleSpawnerID
5801                 Vertical     bool
5802                 CollisionRm  bool
5803                 AttachedAOID AOID
5804                 AnimParams   TileAnim
5805                 Glow         uint8
5806                 AOCollision  bool
5807                 NodeParam0   Content
5808                 NodeParam2   uint8
5809                 NodeTile     uint8
5810         }))(obj)).Pos {
5811                 for local155 := range ((*(*(struct {
5812                         Amount         uint16
5813                         Duration       float32
5814                         Pos, Vel, Acc  [2][3]float32
5815                         ExpirationTime [2]float32 // in seconds.
5816                         Size           [2]float32
5817                         Collide        bool
5818
5819                         //mt:len32
5820                         Texture
5821
5822                         ID           ParticleSpawnerID
5823                         Vertical     bool
5824                         CollisionRm  bool
5825                         AttachedAOID AOID
5826                         AnimParams   TileAnim
5827                         Glow         uint8
5828                         AOCollision  bool
5829                         NodeParam0   Content
5830                         NodeParam2   uint8
5831                         NodeTile     uint8
5832                 }))(obj)).Pos)[local154] {
5833                         {
5834                                 x := (((*(*(struct {
5835                                         Amount         uint16
5836                                         Duration       float32
5837                                         Pos, Vel, Acc  [2][3]float32
5838                                         ExpirationTime [2]float32 // in seconds.
5839                                         Size           [2]float32
5840                                         Collide        bool
5841
5842                                         //mt:len32
5843                                         Texture
5844
5845                                         ID           ParticleSpawnerID
5846                                         Vertical     bool
5847                                         CollisionRm  bool
5848                                         AttachedAOID AOID
5849                                         AnimParams   TileAnim
5850                                         Glow         uint8
5851                                         AOCollision  bool
5852                                         NodeParam0   Content
5853                                         NodeParam2   uint8
5854                                         NodeTile     uint8
5855                                 }))(obj)).Pos)[local154])[local155]
5856                                 write32(w, math.Float32bits(x))
5857                         }
5858                 }
5859         }
5860         for local156 := range (*(*(struct {
5861                 Amount         uint16
5862                 Duration       float32
5863                 Pos, Vel, Acc  [2][3]float32
5864                 ExpirationTime [2]float32 // in seconds.
5865                 Size           [2]float32
5866                 Collide        bool
5867
5868                 //mt:len32
5869                 Texture
5870
5871                 ID           ParticleSpawnerID
5872                 Vertical     bool
5873                 CollisionRm  bool
5874                 AttachedAOID AOID
5875                 AnimParams   TileAnim
5876                 Glow         uint8
5877                 AOCollision  bool
5878                 NodeParam0   Content
5879                 NodeParam2   uint8
5880                 NodeTile     uint8
5881         }))(obj)).Vel {
5882                 for local157 := range ((*(*(struct {
5883                         Amount         uint16
5884                         Duration       float32
5885                         Pos, Vel, Acc  [2][3]float32
5886                         ExpirationTime [2]float32 // in seconds.
5887                         Size           [2]float32
5888                         Collide        bool
5889
5890                         //mt:len32
5891                         Texture
5892
5893                         ID           ParticleSpawnerID
5894                         Vertical     bool
5895                         CollisionRm  bool
5896                         AttachedAOID AOID
5897                         AnimParams   TileAnim
5898                         Glow         uint8
5899                         AOCollision  bool
5900                         NodeParam0   Content
5901                         NodeParam2   uint8
5902                         NodeTile     uint8
5903                 }))(obj)).Vel)[local156] {
5904                         {
5905                                 x := (((*(*(struct {
5906                                         Amount         uint16
5907                                         Duration       float32
5908                                         Pos, Vel, Acc  [2][3]float32
5909                                         ExpirationTime [2]float32 // in seconds.
5910                                         Size           [2]float32
5911                                         Collide        bool
5912
5913                                         //mt:len32
5914                                         Texture
5915
5916                                         ID           ParticleSpawnerID
5917                                         Vertical     bool
5918                                         CollisionRm  bool
5919                                         AttachedAOID AOID
5920                                         AnimParams   TileAnim
5921                                         Glow         uint8
5922                                         AOCollision  bool
5923                                         NodeParam0   Content
5924                                         NodeParam2   uint8
5925                                         NodeTile     uint8
5926                                 }))(obj)).Vel)[local156])[local157]
5927                                 write32(w, math.Float32bits(x))
5928                         }
5929                 }
5930         }
5931         for local158 := range (*(*(struct {
5932                 Amount         uint16
5933                 Duration       float32
5934                 Pos, Vel, Acc  [2][3]float32
5935                 ExpirationTime [2]float32 // in seconds.
5936                 Size           [2]float32
5937                 Collide        bool
5938
5939                 //mt:len32
5940                 Texture
5941
5942                 ID           ParticleSpawnerID
5943                 Vertical     bool
5944                 CollisionRm  bool
5945                 AttachedAOID AOID
5946                 AnimParams   TileAnim
5947                 Glow         uint8
5948                 AOCollision  bool
5949                 NodeParam0   Content
5950                 NodeParam2   uint8
5951                 NodeTile     uint8
5952         }))(obj)).Acc {
5953                 for local159 := range ((*(*(struct {
5954                         Amount         uint16
5955                         Duration       float32
5956                         Pos, Vel, Acc  [2][3]float32
5957                         ExpirationTime [2]float32 // in seconds.
5958                         Size           [2]float32
5959                         Collide        bool
5960
5961                         //mt:len32
5962                         Texture
5963
5964                         ID           ParticleSpawnerID
5965                         Vertical     bool
5966                         CollisionRm  bool
5967                         AttachedAOID AOID
5968                         AnimParams   TileAnim
5969                         Glow         uint8
5970                         AOCollision  bool
5971                         NodeParam0   Content
5972                         NodeParam2   uint8
5973                         NodeTile     uint8
5974                 }))(obj)).Acc)[local158] {
5975                         {
5976                                 x := (((*(*(struct {
5977                                         Amount         uint16
5978                                         Duration       float32
5979                                         Pos, Vel, Acc  [2][3]float32
5980                                         ExpirationTime [2]float32 // in seconds.
5981                                         Size           [2]float32
5982                                         Collide        bool
5983
5984                                         //mt:len32
5985                                         Texture
5986
5987                                         ID           ParticleSpawnerID
5988                                         Vertical     bool
5989                                         CollisionRm  bool
5990                                         AttachedAOID AOID
5991                                         AnimParams   TileAnim
5992                                         Glow         uint8
5993                                         AOCollision  bool
5994                                         NodeParam0   Content
5995                                         NodeParam2   uint8
5996                                         NodeTile     uint8
5997                                 }))(obj)).Acc)[local158])[local159]
5998                                 write32(w, math.Float32bits(x))
5999                         }
6000                 }
6001         }
6002         for local160 := range (*(*(struct {
6003                 Amount         uint16
6004                 Duration       float32
6005                 Pos, Vel, Acc  [2][3]float32
6006                 ExpirationTime [2]float32 // in seconds.
6007                 Size           [2]float32
6008                 Collide        bool
6009
6010                 //mt:len32
6011                 Texture
6012
6013                 ID           ParticleSpawnerID
6014                 Vertical     bool
6015                 CollisionRm  bool
6016                 AttachedAOID AOID
6017                 AnimParams   TileAnim
6018                 Glow         uint8
6019                 AOCollision  bool
6020                 NodeParam0   Content
6021                 NodeParam2   uint8
6022                 NodeTile     uint8
6023         }))(obj)).ExpirationTime {
6024                 {
6025                         x := ((*(*(struct {
6026                                 Amount         uint16
6027                                 Duration       float32
6028                                 Pos, Vel, Acc  [2][3]float32
6029                                 ExpirationTime [2]float32 // in seconds.
6030                                 Size           [2]float32
6031                                 Collide        bool
6032
6033                                 //mt:len32
6034                                 Texture
6035
6036                                 ID           ParticleSpawnerID
6037                                 Vertical     bool
6038                                 CollisionRm  bool
6039                                 AttachedAOID AOID
6040                                 AnimParams   TileAnim
6041                                 Glow         uint8
6042                                 AOCollision  bool
6043                                 NodeParam0   Content
6044                                 NodeParam2   uint8
6045                                 NodeTile     uint8
6046                         }))(obj)).ExpirationTime)[local160]
6047                         write32(w, math.Float32bits(x))
6048                 }
6049         }
6050         for local161 := range (*(*(struct {
6051                 Amount         uint16
6052                 Duration       float32
6053                 Pos, Vel, Acc  [2][3]float32
6054                 ExpirationTime [2]float32 // in seconds.
6055                 Size           [2]float32
6056                 Collide        bool
6057
6058                 //mt:len32
6059                 Texture
6060
6061                 ID           ParticleSpawnerID
6062                 Vertical     bool
6063                 CollisionRm  bool
6064                 AttachedAOID AOID
6065                 AnimParams   TileAnim
6066                 Glow         uint8
6067                 AOCollision  bool
6068                 NodeParam0   Content
6069                 NodeParam2   uint8
6070                 NodeTile     uint8
6071         }))(obj)).Size {
6072                 {
6073                         x := ((*(*(struct {
6074                                 Amount         uint16
6075                                 Duration       float32
6076                                 Pos, Vel, Acc  [2][3]float32
6077                                 ExpirationTime [2]float32 // in seconds.
6078                                 Size           [2]float32
6079                                 Collide        bool
6080
6081                                 //mt:len32
6082                                 Texture
6083
6084                                 ID           ParticleSpawnerID
6085                                 Vertical     bool
6086                                 CollisionRm  bool
6087                                 AttachedAOID AOID
6088                                 AnimParams   TileAnim
6089                                 Glow         uint8
6090                                 AOCollision  bool
6091                                 NodeParam0   Content
6092                                 NodeParam2   uint8
6093                                 NodeTile     uint8
6094                         }))(obj)).Size)[local161]
6095                         write32(w, math.Float32bits(x))
6096                 }
6097         }
6098         {
6099                 x := (*(*(struct {
6100                         Amount         uint16
6101                         Duration       float32
6102                         Pos, Vel, Acc  [2][3]float32
6103                         ExpirationTime [2]float32 // in seconds.
6104                         Size           [2]float32
6105                         Collide        bool
6106
6107                         //mt:len32
6108                         Texture
6109
6110                         ID           ParticleSpawnerID
6111                         Vertical     bool
6112                         CollisionRm  bool
6113                         AttachedAOID AOID
6114                         AnimParams   TileAnim
6115                         Glow         uint8
6116                         AOCollision  bool
6117                         NodeParam0   Content
6118                         NodeParam2   uint8
6119                         NodeTile     uint8
6120                 }))(obj)).Collide
6121                 if x {
6122                         write8(w, 1)
6123                 } else {
6124                         write8(w, 0)
6125                 }
6126         }
6127         if len(([]byte(*(*string)(&((*(*(struct {
6128                 Amount         uint16
6129                 Duration       float32
6130                 Pos, Vel, Acc  [2][3]float32
6131                 ExpirationTime [2]float32 // in seconds.
6132                 Size           [2]float32
6133                 Collide        bool
6134
6135                 //mt:len32
6136                 Texture
6137
6138                 ID           ParticleSpawnerID
6139                 Vertical     bool
6140                 CollisionRm  bool
6141                 AttachedAOID AOID
6142                 AnimParams   TileAnim
6143                 Glow         uint8
6144                 AOCollision  bool
6145                 NodeParam0   Content
6146                 NodeParam2   uint8
6147                 NodeTile     uint8
6148         }))(obj)).Texture))))) > math.MaxUint32 {
6149                 chk(ErrTooLong)
6150         }
6151         {
6152                 x := uint32(len(([]byte(*(*string)(&((*(*(struct {
6153                         Amount         uint16
6154                         Duration       float32
6155                         Pos, Vel, Acc  [2][3]float32
6156                         ExpirationTime [2]float32 // in seconds.
6157                         Size           [2]float32
6158                         Collide        bool
6159
6160                         //mt:len32
6161                         Texture
6162
6163                         ID           ParticleSpawnerID
6164                         Vertical     bool
6165                         CollisionRm  bool
6166                         AttachedAOID AOID
6167                         AnimParams   TileAnim
6168                         Glow         uint8
6169                         AOCollision  bool
6170                         NodeParam0   Content
6171                         NodeParam2   uint8
6172                         NodeTile     uint8
6173                 }))(obj)).Texture))))))
6174                 write32(w, uint32(x))
6175         }
6176         {
6177                 _, err := w.Write(([]byte(*(*string)(&((*(*(struct {
6178                         Amount         uint16
6179                         Duration       float32
6180                         Pos, Vel, Acc  [2][3]float32
6181                         ExpirationTime [2]float32 // in seconds.
6182                         Size           [2]float32
6183                         Collide        bool
6184
6185                         //mt:len32
6186                         Texture
6187
6188                         ID           ParticleSpawnerID
6189                         Vertical     bool
6190                         CollisionRm  bool
6191                         AttachedAOID AOID
6192                         AnimParams   TileAnim
6193                         Glow         uint8
6194                         AOCollision  bool
6195                         NodeParam0   Content
6196                         NodeParam2   uint8
6197                         NodeTile     uint8
6198                 }))(obj)).Texture))))[:])
6199                 chk(err)
6200         }
6201         if err := pcall(func() {
6202                 ((*(*(struct {
6203                         Amount         uint16
6204                         Duration       float32
6205                         Pos, Vel, Acc  [2][3]float32
6206                         ExpirationTime [2]float32 // in seconds.
6207                         Size           [2]float32
6208                         Collide        bool
6209
6210                         //mt:len32
6211                         Texture
6212
6213                         ID           ParticleSpawnerID
6214                         Vertical     bool
6215                         CollisionRm  bool
6216                         AttachedAOID AOID
6217                         AnimParams   TileAnim
6218                         Glow         uint8
6219                         AOCollision  bool
6220                         NodeParam0   Content
6221                         NodeParam2   uint8
6222                         NodeTile     uint8
6223                 }))(obj)).ID).serialize(w)
6224         }); err != nil {
6225                 if err == io.EOF {
6226                         chk(io.EOF)
6227                 }
6228                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
6229         }
6230         {
6231                 x := (*(*(struct {
6232                         Amount         uint16
6233                         Duration       float32
6234                         Pos, Vel, Acc  [2][3]float32
6235                         ExpirationTime [2]float32 // in seconds.
6236                         Size           [2]float32
6237                         Collide        bool
6238
6239                         //mt:len32
6240                         Texture
6241
6242                         ID           ParticleSpawnerID
6243                         Vertical     bool
6244                         CollisionRm  bool
6245                         AttachedAOID AOID
6246                         AnimParams   TileAnim
6247                         Glow         uint8
6248                         AOCollision  bool
6249                         NodeParam0   Content
6250                         NodeParam2   uint8
6251                         NodeTile     uint8
6252                 }))(obj)).Vertical
6253                 if x {
6254                         write8(w, 1)
6255                 } else {
6256                         write8(w, 0)
6257                 }
6258         }
6259         {
6260                 x := (*(*(struct {
6261                         Amount         uint16
6262                         Duration       float32
6263                         Pos, Vel, Acc  [2][3]float32
6264                         ExpirationTime [2]float32 // in seconds.
6265                         Size           [2]float32
6266                         Collide        bool
6267
6268                         //mt:len32
6269                         Texture
6270
6271                         ID           ParticleSpawnerID
6272                         Vertical     bool
6273                         CollisionRm  bool
6274                         AttachedAOID AOID
6275                         AnimParams   TileAnim
6276                         Glow         uint8
6277                         AOCollision  bool
6278                         NodeParam0   Content
6279                         NodeParam2   uint8
6280                         NodeTile     uint8
6281                 }))(obj)).CollisionRm
6282                 if x {
6283                         write8(w, 1)
6284                 } else {
6285                         write8(w, 0)
6286                 }
6287         }
6288         if err := pcall(func() {
6289                 ((*(*(struct {
6290                         Amount         uint16
6291                         Duration       float32
6292                         Pos, Vel, Acc  [2][3]float32
6293                         ExpirationTime [2]float32 // in seconds.
6294                         Size           [2]float32
6295                         Collide        bool
6296
6297                         //mt:len32
6298                         Texture
6299
6300                         ID           ParticleSpawnerID
6301                         Vertical     bool
6302                         CollisionRm  bool
6303                         AttachedAOID AOID
6304                         AnimParams   TileAnim
6305                         Glow         uint8
6306                         AOCollision  bool
6307                         NodeParam0   Content
6308                         NodeParam2   uint8
6309                         NodeTile     uint8
6310                 }))(obj)).AttachedAOID).serialize(w)
6311         }); err != nil {
6312                 if err == io.EOF {
6313                         chk(io.EOF)
6314                 }
6315                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
6316         }
6317         if err := pcall(func() {
6318                 ((*(*(struct {
6319                         Amount         uint16
6320                         Duration       float32
6321                         Pos, Vel, Acc  [2][3]float32
6322                         ExpirationTime [2]float32 // in seconds.
6323                         Size           [2]float32
6324                         Collide        bool
6325
6326                         //mt:len32
6327                         Texture
6328
6329                         ID           ParticleSpawnerID
6330                         Vertical     bool
6331                         CollisionRm  bool
6332                         AttachedAOID AOID
6333                         AnimParams   TileAnim
6334                         Glow         uint8
6335                         AOCollision  bool
6336                         NodeParam0   Content
6337                         NodeParam2   uint8
6338                         NodeTile     uint8
6339                 }))(obj)).AnimParams).serialize(w)
6340         }); err != nil {
6341                 if err == io.EOF {
6342                         chk(io.EOF)
6343                 }
6344                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
6345         }
6346         {
6347                 x := (*(*(struct {
6348                         Amount         uint16
6349                         Duration       float32
6350                         Pos, Vel, Acc  [2][3]float32
6351                         ExpirationTime [2]float32 // in seconds.
6352                         Size           [2]float32
6353                         Collide        bool
6354
6355                         //mt:len32
6356                         Texture
6357
6358                         ID           ParticleSpawnerID
6359                         Vertical     bool
6360                         CollisionRm  bool
6361                         AttachedAOID AOID
6362                         AnimParams   TileAnim
6363                         Glow         uint8
6364                         AOCollision  bool
6365                         NodeParam0   Content
6366                         NodeParam2   uint8
6367                         NodeTile     uint8
6368                 }))(obj)).Glow
6369                 write8(w, uint8(x))
6370         }
6371         {
6372                 x := (*(*(struct {
6373                         Amount         uint16
6374                         Duration       float32
6375                         Pos, Vel, Acc  [2][3]float32
6376                         ExpirationTime [2]float32 // in seconds.
6377                         Size           [2]float32
6378                         Collide        bool
6379
6380                         //mt:len32
6381                         Texture
6382
6383                         ID           ParticleSpawnerID
6384                         Vertical     bool
6385                         CollisionRm  bool
6386                         AttachedAOID AOID
6387                         AnimParams   TileAnim
6388                         Glow         uint8
6389                         AOCollision  bool
6390                         NodeParam0   Content
6391                         NodeParam2   uint8
6392                         NodeTile     uint8
6393                 }))(obj)).AOCollision
6394                 if x {
6395                         write8(w, 1)
6396                 } else {
6397                         write8(w, 0)
6398                 }
6399         }
6400         if err := pcall(func() {
6401                 ((*(*(struct {
6402                         Amount         uint16
6403                         Duration       float32
6404                         Pos, Vel, Acc  [2][3]float32
6405                         ExpirationTime [2]float32 // in seconds.
6406                         Size           [2]float32
6407                         Collide        bool
6408
6409                         //mt:len32
6410                         Texture
6411
6412                         ID           ParticleSpawnerID
6413                         Vertical     bool
6414                         CollisionRm  bool
6415                         AttachedAOID AOID
6416                         AnimParams   TileAnim
6417                         Glow         uint8
6418                         AOCollision  bool
6419                         NodeParam0   Content
6420                         NodeParam2   uint8
6421                         NodeTile     uint8
6422                 }))(obj)).NodeParam0).serialize(w)
6423         }); err != nil {
6424                 if err == io.EOF {
6425                         chk(io.EOF)
6426                 }
6427                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
6428         }
6429         {
6430                 x := (*(*(struct {
6431                         Amount         uint16
6432                         Duration       float32
6433                         Pos, Vel, Acc  [2][3]float32
6434                         ExpirationTime [2]float32 // in seconds.
6435                         Size           [2]float32
6436                         Collide        bool
6437
6438                         //mt:len32
6439                         Texture
6440
6441                         ID           ParticleSpawnerID
6442                         Vertical     bool
6443                         CollisionRm  bool
6444                         AttachedAOID AOID
6445                         AnimParams   TileAnim
6446                         Glow         uint8
6447                         AOCollision  bool
6448                         NodeParam0   Content
6449                         NodeParam2   uint8
6450                         NodeTile     uint8
6451                 }))(obj)).NodeParam2
6452                 write8(w, uint8(x))
6453         }
6454         {
6455                 x := (*(*(struct {
6456                         Amount         uint16
6457                         Duration       float32
6458                         Pos, Vel, Acc  [2][3]float32
6459                         ExpirationTime [2]float32 // in seconds.
6460                         Size           [2]float32
6461                         Collide        bool
6462
6463                         //mt:len32
6464                         Texture
6465
6466                         ID           ParticleSpawnerID
6467                         Vertical     bool
6468                         CollisionRm  bool
6469                         AttachedAOID AOID
6470                         AnimParams   TileAnim
6471                         Glow         uint8
6472                         AOCollision  bool
6473                         NodeParam0   Content
6474                         NodeParam2   uint8
6475                         NodeTile     uint8
6476                 }))(obj)).NodeTile
6477                 write8(w, uint8(x))
6478         }
6479 }
6480
6481 func (obj *ToCltAddParticleSpawner) deserialize(r io.Reader) {
6482         {
6483                 p := &(*(*(struct {
6484                         Amount         uint16
6485                         Duration       float32
6486                         Pos, Vel, Acc  [2][3]float32
6487                         ExpirationTime [2]float32 // in seconds.
6488                         Size           [2]float32
6489                         Collide        bool
6490
6491                         //mt:len32
6492                         Texture
6493
6494                         ID           ParticleSpawnerID
6495                         Vertical     bool
6496                         CollisionRm  bool
6497                         AttachedAOID AOID
6498                         AnimParams   TileAnim
6499                         Glow         uint8
6500                         AOCollision  bool
6501                         NodeParam0   Content
6502                         NodeParam2   uint8
6503                         NodeTile     uint8
6504                 }))(obj)).Amount
6505                 *p = read16(r)
6506         }
6507         {
6508                 p := &(*(*(struct {
6509                         Amount         uint16
6510                         Duration       float32
6511                         Pos, Vel, Acc  [2][3]float32
6512                         ExpirationTime [2]float32 // in seconds.
6513                         Size           [2]float32
6514                         Collide        bool
6515
6516                         //mt:len32
6517                         Texture
6518
6519                         ID           ParticleSpawnerID
6520                         Vertical     bool
6521                         CollisionRm  bool
6522                         AttachedAOID AOID
6523                         AnimParams   TileAnim
6524                         Glow         uint8
6525                         AOCollision  bool
6526                         NodeParam0   Content
6527                         NodeParam2   uint8
6528                         NodeTile     uint8
6529                 }))(obj)).Duration
6530                 *p = math.Float32frombits(read32(r))
6531         }
6532         for local162 := range (*(*(struct {
6533                 Amount         uint16
6534                 Duration       float32
6535                 Pos, Vel, Acc  [2][3]float32
6536                 ExpirationTime [2]float32 // in seconds.
6537                 Size           [2]float32
6538                 Collide        bool
6539
6540                 //mt:len32
6541                 Texture
6542
6543                 ID           ParticleSpawnerID
6544                 Vertical     bool
6545                 CollisionRm  bool
6546                 AttachedAOID AOID
6547                 AnimParams   TileAnim
6548                 Glow         uint8
6549                 AOCollision  bool
6550                 NodeParam0   Content
6551                 NodeParam2   uint8
6552                 NodeTile     uint8
6553         }))(obj)).Pos {
6554                 for local163 := range ((*(*(struct {
6555                         Amount         uint16
6556                         Duration       float32
6557                         Pos, Vel, Acc  [2][3]float32
6558                         ExpirationTime [2]float32 // in seconds.
6559                         Size           [2]float32
6560                         Collide        bool
6561
6562                         //mt:len32
6563                         Texture
6564
6565                         ID           ParticleSpawnerID
6566                         Vertical     bool
6567                         CollisionRm  bool
6568                         AttachedAOID AOID
6569                         AnimParams   TileAnim
6570                         Glow         uint8
6571                         AOCollision  bool
6572                         NodeParam0   Content
6573                         NodeParam2   uint8
6574                         NodeTile     uint8
6575                 }))(obj)).Pos)[local162] {
6576                         {
6577                                 p := &(((*(*(struct {
6578                                         Amount         uint16
6579                                         Duration       float32
6580                                         Pos, Vel, Acc  [2][3]float32
6581                                         ExpirationTime [2]float32 // in seconds.
6582                                         Size           [2]float32
6583                                         Collide        bool
6584
6585                                         //mt:len32
6586                                         Texture
6587
6588                                         ID           ParticleSpawnerID
6589                                         Vertical     bool
6590                                         CollisionRm  bool
6591                                         AttachedAOID AOID
6592                                         AnimParams   TileAnim
6593                                         Glow         uint8
6594                                         AOCollision  bool
6595                                         NodeParam0   Content
6596                                         NodeParam2   uint8
6597                                         NodeTile     uint8
6598                                 }))(obj)).Pos)[local162])[local163]
6599                                 *p = math.Float32frombits(read32(r))
6600                         }
6601                 }
6602         }
6603         for local164 := range (*(*(struct {
6604                 Amount         uint16
6605                 Duration       float32
6606                 Pos, Vel, Acc  [2][3]float32
6607                 ExpirationTime [2]float32 // in seconds.
6608                 Size           [2]float32
6609                 Collide        bool
6610
6611                 //mt:len32
6612                 Texture
6613
6614                 ID           ParticleSpawnerID
6615                 Vertical     bool
6616                 CollisionRm  bool
6617                 AttachedAOID AOID
6618                 AnimParams   TileAnim
6619                 Glow         uint8
6620                 AOCollision  bool
6621                 NodeParam0   Content
6622                 NodeParam2   uint8
6623                 NodeTile     uint8
6624         }))(obj)).Vel {
6625                 for local165 := range ((*(*(struct {
6626                         Amount         uint16
6627                         Duration       float32
6628                         Pos, Vel, Acc  [2][3]float32
6629                         ExpirationTime [2]float32 // in seconds.
6630                         Size           [2]float32
6631                         Collide        bool
6632
6633                         //mt:len32
6634                         Texture
6635
6636                         ID           ParticleSpawnerID
6637                         Vertical     bool
6638                         CollisionRm  bool
6639                         AttachedAOID AOID
6640                         AnimParams   TileAnim
6641                         Glow         uint8
6642                         AOCollision  bool
6643                         NodeParam0   Content
6644                         NodeParam2   uint8
6645                         NodeTile     uint8
6646                 }))(obj)).Vel)[local164] {
6647                         {
6648                                 p := &(((*(*(struct {
6649                                         Amount         uint16
6650                                         Duration       float32
6651                                         Pos, Vel, Acc  [2][3]float32
6652                                         ExpirationTime [2]float32 // in seconds.
6653                                         Size           [2]float32
6654                                         Collide        bool
6655
6656                                         //mt:len32
6657                                         Texture
6658
6659                                         ID           ParticleSpawnerID
6660                                         Vertical     bool
6661                                         CollisionRm  bool
6662                                         AttachedAOID AOID
6663                                         AnimParams   TileAnim
6664                                         Glow         uint8
6665                                         AOCollision  bool
6666                                         NodeParam0   Content
6667                                         NodeParam2   uint8
6668                                         NodeTile     uint8
6669                                 }))(obj)).Vel)[local164])[local165]
6670                                 *p = math.Float32frombits(read32(r))
6671                         }
6672                 }
6673         }
6674         for local166 := range (*(*(struct {
6675                 Amount         uint16
6676                 Duration       float32
6677                 Pos, Vel, Acc  [2][3]float32
6678                 ExpirationTime [2]float32 // in seconds.
6679                 Size           [2]float32
6680                 Collide        bool
6681
6682                 //mt:len32
6683                 Texture
6684
6685                 ID           ParticleSpawnerID
6686                 Vertical     bool
6687                 CollisionRm  bool
6688                 AttachedAOID AOID
6689                 AnimParams   TileAnim
6690                 Glow         uint8
6691                 AOCollision  bool
6692                 NodeParam0   Content
6693                 NodeParam2   uint8
6694                 NodeTile     uint8
6695         }))(obj)).Acc {
6696                 for local167 := range ((*(*(struct {
6697                         Amount         uint16
6698                         Duration       float32
6699                         Pos, Vel, Acc  [2][3]float32
6700                         ExpirationTime [2]float32 // in seconds.
6701                         Size           [2]float32
6702                         Collide        bool
6703
6704                         //mt:len32
6705                         Texture
6706
6707                         ID           ParticleSpawnerID
6708                         Vertical     bool
6709                         CollisionRm  bool
6710                         AttachedAOID AOID
6711                         AnimParams   TileAnim
6712                         Glow         uint8
6713                         AOCollision  bool
6714                         NodeParam0   Content
6715                         NodeParam2   uint8
6716                         NodeTile     uint8
6717                 }))(obj)).Acc)[local166] {
6718                         {
6719                                 p := &(((*(*(struct {
6720                                         Amount         uint16
6721                                         Duration       float32
6722                                         Pos, Vel, Acc  [2][3]float32
6723                                         ExpirationTime [2]float32 // in seconds.
6724                                         Size           [2]float32
6725                                         Collide        bool
6726
6727                                         //mt:len32
6728                                         Texture
6729
6730                                         ID           ParticleSpawnerID
6731                                         Vertical     bool
6732                                         CollisionRm  bool
6733                                         AttachedAOID AOID
6734                                         AnimParams   TileAnim
6735                                         Glow         uint8
6736                                         AOCollision  bool
6737                                         NodeParam0   Content
6738                                         NodeParam2   uint8
6739                                         NodeTile     uint8
6740                                 }))(obj)).Acc)[local166])[local167]
6741                                 *p = math.Float32frombits(read32(r))
6742                         }
6743                 }
6744         }
6745         for local168 := range (*(*(struct {
6746                 Amount         uint16
6747                 Duration       float32
6748                 Pos, Vel, Acc  [2][3]float32
6749                 ExpirationTime [2]float32 // in seconds.
6750                 Size           [2]float32
6751                 Collide        bool
6752
6753                 //mt:len32
6754                 Texture
6755
6756                 ID           ParticleSpawnerID
6757                 Vertical     bool
6758                 CollisionRm  bool
6759                 AttachedAOID AOID
6760                 AnimParams   TileAnim
6761                 Glow         uint8
6762                 AOCollision  bool
6763                 NodeParam0   Content
6764                 NodeParam2   uint8
6765                 NodeTile     uint8
6766         }))(obj)).ExpirationTime {
6767                 {
6768                         p := &((*(*(struct {
6769                                 Amount         uint16
6770                                 Duration       float32
6771                                 Pos, Vel, Acc  [2][3]float32
6772                                 ExpirationTime [2]float32 // in seconds.
6773                                 Size           [2]float32
6774                                 Collide        bool
6775
6776                                 //mt:len32
6777                                 Texture
6778
6779                                 ID           ParticleSpawnerID
6780                                 Vertical     bool
6781                                 CollisionRm  bool
6782                                 AttachedAOID AOID
6783                                 AnimParams   TileAnim
6784                                 Glow         uint8
6785                                 AOCollision  bool
6786                                 NodeParam0   Content
6787                                 NodeParam2   uint8
6788                                 NodeTile     uint8
6789                         }))(obj)).ExpirationTime)[local168]
6790                         *p = math.Float32frombits(read32(r))
6791                 }
6792         }
6793         for local169 := range (*(*(struct {
6794                 Amount         uint16
6795                 Duration       float32
6796                 Pos, Vel, Acc  [2][3]float32
6797                 ExpirationTime [2]float32 // in seconds.
6798                 Size           [2]float32
6799                 Collide        bool
6800
6801                 //mt:len32
6802                 Texture
6803
6804                 ID           ParticleSpawnerID
6805                 Vertical     bool
6806                 CollisionRm  bool
6807                 AttachedAOID AOID
6808                 AnimParams   TileAnim
6809                 Glow         uint8
6810                 AOCollision  bool
6811                 NodeParam0   Content
6812                 NodeParam2   uint8
6813                 NodeTile     uint8
6814         }))(obj)).Size {
6815                 {
6816                         p := &((*(*(struct {
6817                                 Amount         uint16
6818                                 Duration       float32
6819                                 Pos, Vel, Acc  [2][3]float32
6820                                 ExpirationTime [2]float32 // in seconds.
6821                                 Size           [2]float32
6822                                 Collide        bool
6823
6824                                 //mt:len32
6825                                 Texture
6826
6827                                 ID           ParticleSpawnerID
6828                                 Vertical     bool
6829                                 CollisionRm  bool
6830                                 AttachedAOID AOID
6831                                 AnimParams   TileAnim
6832                                 Glow         uint8
6833                                 AOCollision  bool
6834                                 NodeParam0   Content
6835                                 NodeParam2   uint8
6836                                 NodeTile     uint8
6837                         }))(obj)).Size)[local169]
6838                         *p = math.Float32frombits(read32(r))
6839                 }
6840         }
6841         {
6842                 p := &(*(*(struct {
6843                         Amount         uint16
6844                         Duration       float32
6845                         Pos, Vel, Acc  [2][3]float32
6846                         ExpirationTime [2]float32 // in seconds.
6847                         Size           [2]float32
6848                         Collide        bool
6849
6850                         //mt:len32
6851                         Texture
6852
6853                         ID           ParticleSpawnerID
6854                         Vertical     bool
6855                         CollisionRm  bool
6856                         AttachedAOID AOID
6857                         AnimParams   TileAnim
6858                         Glow         uint8
6859                         AOCollision  bool
6860                         NodeParam0   Content
6861                         NodeParam2   uint8
6862                         NodeTile     uint8
6863                 }))(obj)).Collide
6864                 switch n := read8(r); n {
6865                 case 0:
6866                         *p = false
6867                 case 1:
6868                         *p = true
6869                 default:
6870                         chk(fmt.Errorf("invalid bool: %d", n))
6871                 }
6872         }
6873         var local170 []uint8
6874         var local171 uint32
6875         {
6876                 p := &local171
6877                 *p = read32(r)
6878         }
6879         (local170) = make([]uint8, local171)
6880         {
6881                 _, err := io.ReadFull(r, (local170)[:])
6882                 chk(err)
6883         }
6884         (*(*string)(&((*(*(struct {
6885                 Amount         uint16
6886                 Duration       float32
6887                 Pos, Vel, Acc  [2][3]float32
6888                 ExpirationTime [2]float32 // in seconds.
6889                 Size           [2]float32
6890                 Collide        bool
6891
6892                 //mt:len32
6893                 Texture
6894
6895                 ID           ParticleSpawnerID
6896                 Vertical     bool
6897                 CollisionRm  bool
6898                 AttachedAOID AOID
6899                 AnimParams   TileAnim
6900                 Glow         uint8
6901                 AOCollision  bool
6902                 NodeParam0   Content
6903                 NodeParam2   uint8
6904                 NodeTile     uint8
6905         }))(obj)).Texture))) = string(local170)
6906         if err := pcall(func() {
6907                 ((*(*(struct {
6908                         Amount         uint16
6909                         Duration       float32
6910                         Pos, Vel, Acc  [2][3]float32
6911                         ExpirationTime [2]float32 // in seconds.
6912                         Size           [2]float32
6913                         Collide        bool
6914
6915                         //mt:len32
6916                         Texture
6917
6918                         ID           ParticleSpawnerID
6919                         Vertical     bool
6920                         CollisionRm  bool
6921                         AttachedAOID AOID
6922                         AnimParams   TileAnim
6923                         Glow         uint8
6924                         AOCollision  bool
6925                         NodeParam0   Content
6926                         NodeParam2   uint8
6927                         NodeTile     uint8
6928                 }))(obj)).ID).deserialize(r)
6929         }); err != nil {
6930                 if err == io.EOF {
6931                         chk(io.EOF)
6932                 }
6933                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
6934         }
6935         {
6936                 p := &(*(*(struct {
6937                         Amount         uint16
6938                         Duration       float32
6939                         Pos, Vel, Acc  [2][3]float32
6940                         ExpirationTime [2]float32 // in seconds.
6941                         Size           [2]float32
6942                         Collide        bool
6943
6944                         //mt:len32
6945                         Texture
6946
6947                         ID           ParticleSpawnerID
6948                         Vertical     bool
6949                         CollisionRm  bool
6950                         AttachedAOID AOID
6951                         AnimParams   TileAnim
6952                         Glow         uint8
6953                         AOCollision  bool
6954                         NodeParam0   Content
6955                         NodeParam2   uint8
6956                         NodeTile     uint8
6957                 }))(obj)).Vertical
6958                 switch n := read8(r); n {
6959                 case 0:
6960                         *p = false
6961                 case 1:
6962                         *p = true
6963                 default:
6964                         chk(fmt.Errorf("invalid bool: %d", n))
6965                 }
6966         }
6967         {
6968                 p := &(*(*(struct {
6969                         Amount         uint16
6970                         Duration       float32
6971                         Pos, Vel, Acc  [2][3]float32
6972                         ExpirationTime [2]float32 // in seconds.
6973                         Size           [2]float32
6974                         Collide        bool
6975
6976                         //mt:len32
6977                         Texture
6978
6979                         ID           ParticleSpawnerID
6980                         Vertical     bool
6981                         CollisionRm  bool
6982                         AttachedAOID AOID
6983                         AnimParams   TileAnim
6984                         Glow         uint8
6985                         AOCollision  bool
6986                         NodeParam0   Content
6987                         NodeParam2   uint8
6988                         NodeTile     uint8
6989                 }))(obj)).CollisionRm
6990                 switch n := read8(r); n {
6991                 case 0:
6992                         *p = false
6993                 case 1:
6994                         *p = true
6995                 default:
6996                         chk(fmt.Errorf("invalid bool: %d", n))
6997                 }
6998         }
6999         if err := pcall(func() {
7000                 ((*(*(struct {
7001                         Amount         uint16
7002                         Duration       float32
7003                         Pos, Vel, Acc  [2][3]float32
7004                         ExpirationTime [2]float32 // in seconds.
7005                         Size           [2]float32
7006                         Collide        bool
7007
7008                         //mt:len32
7009                         Texture
7010
7011                         ID           ParticleSpawnerID
7012                         Vertical     bool
7013                         CollisionRm  bool
7014                         AttachedAOID AOID
7015                         AnimParams   TileAnim
7016                         Glow         uint8
7017                         AOCollision  bool
7018                         NodeParam0   Content
7019                         NodeParam2   uint8
7020                         NodeTile     uint8
7021                 }))(obj)).AttachedAOID).deserialize(r)
7022         }); err != nil {
7023                 if err == io.EOF {
7024                         chk(io.EOF)
7025                 }
7026                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
7027         }
7028         if err := pcall(func() {
7029                 ((*(*(struct {
7030                         Amount         uint16
7031                         Duration       float32
7032                         Pos, Vel, Acc  [2][3]float32
7033                         ExpirationTime [2]float32 // in seconds.
7034                         Size           [2]float32
7035                         Collide        bool
7036
7037                         //mt:len32
7038                         Texture
7039
7040                         ID           ParticleSpawnerID
7041                         Vertical     bool
7042                         CollisionRm  bool
7043                         AttachedAOID AOID
7044                         AnimParams   TileAnim
7045                         Glow         uint8
7046                         AOCollision  bool
7047                         NodeParam0   Content
7048                         NodeParam2   uint8
7049                         NodeTile     uint8
7050                 }))(obj)).AnimParams).deserialize(r)
7051         }); err != nil {
7052                 if err == io.EOF {
7053                         chk(io.EOF)
7054                 }
7055                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
7056         }
7057         {
7058                 p := &(*(*(struct {
7059                         Amount         uint16
7060                         Duration       float32
7061                         Pos, Vel, Acc  [2][3]float32
7062                         ExpirationTime [2]float32 // in seconds.
7063                         Size           [2]float32
7064                         Collide        bool
7065
7066                         //mt:len32
7067                         Texture
7068
7069                         ID           ParticleSpawnerID
7070                         Vertical     bool
7071                         CollisionRm  bool
7072                         AttachedAOID AOID
7073                         AnimParams   TileAnim
7074                         Glow         uint8
7075                         AOCollision  bool
7076                         NodeParam0   Content
7077                         NodeParam2   uint8
7078                         NodeTile     uint8
7079                 }))(obj)).Glow
7080                 *p = read8(r)
7081         }
7082         {
7083                 p := &(*(*(struct {
7084                         Amount         uint16
7085                         Duration       float32
7086                         Pos, Vel, Acc  [2][3]float32
7087                         ExpirationTime [2]float32 // in seconds.
7088                         Size           [2]float32
7089                         Collide        bool
7090
7091                         //mt:len32
7092                         Texture
7093
7094                         ID           ParticleSpawnerID
7095                         Vertical     bool
7096                         CollisionRm  bool
7097                         AttachedAOID AOID
7098                         AnimParams   TileAnim
7099                         Glow         uint8
7100                         AOCollision  bool
7101                         NodeParam0   Content
7102                         NodeParam2   uint8
7103                         NodeTile     uint8
7104                 }))(obj)).AOCollision
7105                 switch n := read8(r); n {
7106                 case 0:
7107                         *p = false
7108                 case 1:
7109                         *p = true
7110                 default:
7111                         chk(fmt.Errorf("invalid bool: %d", n))
7112                 }
7113         }
7114         if err := pcall(func() {
7115                 ((*(*(struct {
7116                         Amount         uint16
7117                         Duration       float32
7118                         Pos, Vel, Acc  [2][3]float32
7119                         ExpirationTime [2]float32 // in seconds.
7120                         Size           [2]float32
7121                         Collide        bool
7122
7123                         //mt:len32
7124                         Texture
7125
7126                         ID           ParticleSpawnerID
7127                         Vertical     bool
7128                         CollisionRm  bool
7129                         AttachedAOID AOID
7130                         AnimParams   TileAnim
7131                         Glow         uint8
7132                         AOCollision  bool
7133                         NodeParam0   Content
7134                         NodeParam2   uint8
7135                         NodeTile     uint8
7136                 }))(obj)).NodeParam0).deserialize(r)
7137         }); err != nil {
7138                 if err == io.EOF {
7139                         chk(io.EOF)
7140                 }
7141                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
7142         }
7143         {
7144                 p := &(*(*(struct {
7145                         Amount         uint16
7146                         Duration       float32
7147                         Pos, Vel, Acc  [2][3]float32
7148                         ExpirationTime [2]float32 // in seconds.
7149                         Size           [2]float32
7150                         Collide        bool
7151
7152                         //mt:len32
7153                         Texture
7154
7155                         ID           ParticleSpawnerID
7156                         Vertical     bool
7157                         CollisionRm  bool
7158                         AttachedAOID AOID
7159                         AnimParams   TileAnim
7160                         Glow         uint8
7161                         AOCollision  bool
7162                         NodeParam0   Content
7163                         NodeParam2   uint8
7164                         NodeTile     uint8
7165                 }))(obj)).NodeParam2
7166                 *p = read8(r)
7167         }
7168         {
7169                 p := &(*(*(struct {
7170                         Amount         uint16
7171                         Duration       float32
7172                         Pos, Vel, Acc  [2][3]float32
7173                         ExpirationTime [2]float32 // in seconds.
7174                         Size           [2]float32
7175                         Collide        bool
7176
7177                         //mt:len32
7178                         Texture
7179
7180                         ID           ParticleSpawnerID
7181                         Vertical     bool
7182                         CollisionRm  bool
7183                         AttachedAOID AOID
7184                         AnimParams   TileAnim
7185                         Glow         uint8
7186                         AOCollision  bool
7187                         NodeParam0   Content
7188                         NodeParam2   uint8
7189                         NodeTile     uint8
7190                 }))(obj)).NodeTile
7191                 *p = read8(r)
7192         }
7193 }
7194
7195 func (obj *ToCltAddHUD) serialize(w io.Writer) {
7196         if err := pcall(func() {
7197                 ((*(*(struct {
7198                         ID HUDID
7199                         HUD
7200                 }))(obj)).ID).serialize(w)
7201         }); err != nil {
7202                 if err == io.EOF {
7203                         chk(io.EOF)
7204                 }
7205                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7206         }
7207         if err := pcall(func() {
7208                 ((*(*(struct {
7209                         ID HUDID
7210                         HUD
7211                 }))(obj)).HUD).serialize(w)
7212         }); err != nil {
7213                 if err == io.EOF {
7214                         chk(io.EOF)
7215                 }
7216                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUD", err))
7217         }
7218 }
7219
7220 func (obj *ToCltAddHUD) deserialize(r io.Reader) {
7221         if err := pcall(func() {
7222                 ((*(*(struct {
7223                         ID HUDID
7224                         HUD
7225                 }))(obj)).ID).deserialize(r)
7226         }); err != nil {
7227                 if err == io.EOF {
7228                         chk(io.EOF)
7229                 }
7230                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7231         }
7232         if err := pcall(func() {
7233                 ((*(*(struct {
7234                         ID HUDID
7235                         HUD
7236                 }))(obj)).HUD).deserialize(r)
7237         }); err != nil {
7238                 if err == io.EOF {
7239                         chk(io.EOF)
7240                 }
7241                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUD", err))
7242         }
7243 }
7244
7245 func (obj *ToCltRmHUD) serialize(w io.Writer) {
7246         if err := pcall(func() {
7247                 ((*(*(struct {
7248                         ID HUDID
7249                 }))(obj)).ID).serialize(w)
7250         }); err != nil {
7251                 if err == io.EOF {
7252                         chk(io.EOF)
7253                 }
7254                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7255         }
7256 }
7257
7258 func (obj *ToCltRmHUD) deserialize(r io.Reader) {
7259         if err := pcall(func() {
7260                 ((*(*(struct {
7261                         ID HUDID
7262                 }))(obj)).ID).deserialize(r)
7263         }); err != nil {
7264                 if err == io.EOF {
7265                         chk(io.EOF)
7266                 }
7267                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7268         }
7269 }
7270
7271 func (obj *ToCltChangeHUD) serialize(w io.Writer) {
7272         if err := pcall(func() {
7273                 ((*(*(struct {
7274                         ID HUDID
7275
7276                         Field HUDField
7277
7278                         //mt:if %s.Field == HUDPos
7279                         Pos [2]float32
7280
7281                         //mt:if %s.Field == HUDName
7282                         Name string
7283
7284                         //mt:if %s.Field == HUDScale
7285                         Scale [2]float32
7286
7287                         //mt:if %s.Field == HUDText
7288                         Text string
7289
7290                         //mt:if %s.Field == HUDNumber
7291                         Number uint32
7292
7293                         //mt:if %s.Field == HUDItem
7294                         Item uint32
7295
7296                         //mt:if %s.Field == HUDDir
7297                         Dir uint32
7298
7299                         //mt:if %s.Field == HUDAlign
7300                         Align [2]float32
7301
7302                         //mt:if %s.Field == HUDOffset
7303                         Offset [2]float32
7304
7305                         //mt:if %s.Field == HUDWorldPos
7306                         WorldPos Pos
7307
7308                         //mt:if %s.Field == HUDSize
7309                         Size [2]int32
7310
7311                         //mt:if %s.Field == HUDZIndex
7312                         ZIndex int32
7313
7314                         //mt:if %s.Field == HUDText2
7315                         Text2 string
7316
7317                         //mt:if %s.Field == HUDStyle
7318                         Style HUDStyleFlags
7319                 }))(obj)).ID).serialize(w)
7320         }); err != nil {
7321                 if err == io.EOF {
7322                         chk(io.EOF)
7323                 }
7324                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
7325         }
7326         if err := pcall(func() {
7327                 ((*(*(struct {
7328                         ID HUDID
7329
7330                         Field HUDField
7331
7332                         //mt:if %s.Field == HUDPos
7333                         Pos [2]float32
7334
7335                         //mt:if %s.Field == HUDName
7336                         Name string
7337
7338                         //mt:if %s.Field == HUDScale
7339                         Scale [2]float32
7340
7341                         //mt:if %s.Field == HUDText
7342                         Text string
7343
7344                         //mt:if %s.Field == HUDNumber
7345                         Number uint32
7346
7347                         //mt:if %s.Field == HUDItem
7348                         Item uint32
7349
7350                         //mt:if %s.Field == HUDDir
7351                         Dir uint32
7352
7353                         //mt:if %s.Field == HUDAlign
7354                         Align [2]float32
7355
7356                         //mt:if %s.Field == HUDOffset
7357                         Offset [2]float32
7358
7359                         //mt:if %s.Field == HUDWorldPos
7360                         WorldPos Pos
7361
7362                         //mt:if %s.Field == HUDSize
7363                         Size [2]int32
7364
7365                         //mt:if %s.Field == HUDZIndex
7366                         ZIndex int32
7367
7368                         //mt:if %s.Field == HUDText2
7369                         Text2 string
7370
7371                         //mt:if %s.Field == HUDStyle
7372                         Style HUDStyleFlags
7373                 }))(obj)).Field).serialize(w)
7374         }); err != nil {
7375                 if err == io.EOF {
7376                         chk(io.EOF)
7377                 }
7378                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDField", err))
7379         }
7380         if !((*(*(struct {
7381                 ID HUDID
7382
7383                 Field HUDField
7384
7385                 //mt:if %s.Field == HUDPos
7386                 Pos [2]float32
7387
7388                 //mt:if %s.Field == HUDName
7389                 Name string
7390
7391                 //mt:if %s.Field == HUDScale
7392                 Scale [2]float32
7393
7394                 //mt:if %s.Field == HUDText
7395                 Text string
7396
7397                 //mt:if %s.Field == HUDNumber
7398                 Number uint32
7399
7400                 //mt:if %s.Field == HUDItem
7401                 Item uint32
7402
7403                 //mt:if %s.Field == HUDDir
7404                 Dir uint32
7405
7406                 //mt:if %s.Field == HUDAlign
7407                 Align [2]float32
7408
7409                 //mt:if %s.Field == HUDOffset
7410                 Offset [2]float32
7411
7412                 //mt:if %s.Field == HUDWorldPos
7413                 WorldPos Pos
7414
7415                 //mt:if %s.Field == HUDSize
7416                 Size [2]int32
7417
7418                 //mt:if %s.Field == HUDZIndex
7419                 ZIndex int32
7420
7421                 //mt:if %s.Field == HUDText2
7422                 Text2 string
7423
7424                 //mt:if %s.Field == HUDStyle
7425                 Style HUDStyleFlags
7426         }))(obj)).Field < hudMax) {
7427                 chk(errors.New("assertion failed: %s.Field < hudMax"))
7428         }
7429         if (*(*(struct {
7430                 ID HUDID
7431
7432                 Field HUDField
7433
7434                 //mt:if %s.Field == HUDPos
7435                 Pos [2]float32
7436
7437                 //mt:if %s.Field == HUDName
7438                 Name string
7439
7440                 //mt:if %s.Field == HUDScale
7441                 Scale [2]float32
7442
7443                 //mt:if %s.Field == HUDText
7444                 Text string
7445
7446                 //mt:if %s.Field == HUDNumber
7447                 Number uint32
7448
7449                 //mt:if %s.Field == HUDItem
7450                 Item uint32
7451
7452                 //mt:if %s.Field == HUDDir
7453                 Dir uint32
7454
7455                 //mt:if %s.Field == HUDAlign
7456                 Align [2]float32
7457
7458                 //mt:if %s.Field == HUDOffset
7459                 Offset [2]float32
7460
7461                 //mt:if %s.Field == HUDWorldPos
7462                 WorldPos Pos
7463
7464                 //mt:if %s.Field == HUDSize
7465                 Size [2]int32
7466
7467                 //mt:if %s.Field == HUDZIndex
7468                 ZIndex int32
7469
7470                 //mt:if %s.Field == HUDText2
7471                 Text2 string
7472
7473                 //mt:if %s.Field == HUDStyle
7474                 Style HUDStyleFlags
7475         }))(obj)).Field == HUDPos {
7476                 for local172 := range (*(*(struct {
7477                         ID HUDID
7478
7479                         Field HUDField
7480
7481                         //mt:if %s.Field == HUDPos
7482                         Pos [2]float32
7483
7484                         //mt:if %s.Field == HUDName
7485                         Name string
7486
7487                         //mt:if %s.Field == HUDScale
7488                         Scale [2]float32
7489
7490                         //mt:if %s.Field == HUDText
7491                         Text string
7492
7493                         //mt:if %s.Field == HUDNumber
7494                         Number uint32
7495
7496                         //mt:if %s.Field == HUDItem
7497                         Item uint32
7498
7499                         //mt:if %s.Field == HUDDir
7500                         Dir uint32
7501
7502                         //mt:if %s.Field == HUDAlign
7503                         Align [2]float32
7504
7505                         //mt:if %s.Field == HUDOffset
7506                         Offset [2]float32
7507
7508                         //mt:if %s.Field == HUDWorldPos
7509                         WorldPos Pos
7510
7511                         //mt:if %s.Field == HUDSize
7512                         Size [2]int32
7513
7514                         //mt:if %s.Field == HUDZIndex
7515                         ZIndex int32
7516
7517                         //mt:if %s.Field == HUDText2
7518                         Text2 string
7519
7520                         //mt:if %s.Field == HUDStyle
7521                         Style HUDStyleFlags
7522                 }))(obj)).Pos {
7523                         {
7524                                 x := ((*(*(struct {
7525                                         ID HUDID
7526
7527                                         Field HUDField
7528
7529                                         //mt:if %s.Field == HUDPos
7530                                         Pos [2]float32
7531
7532                                         //mt:if %s.Field == HUDName
7533                                         Name string
7534
7535                                         //mt:if %s.Field == HUDScale
7536                                         Scale [2]float32
7537
7538                                         //mt:if %s.Field == HUDText
7539                                         Text string
7540
7541                                         //mt:if %s.Field == HUDNumber
7542                                         Number uint32
7543
7544                                         //mt:if %s.Field == HUDItem
7545                                         Item uint32
7546
7547                                         //mt:if %s.Field == HUDDir
7548                                         Dir uint32
7549
7550                                         //mt:if %s.Field == HUDAlign
7551                                         Align [2]float32
7552
7553                                         //mt:if %s.Field == HUDOffset
7554                                         Offset [2]float32
7555
7556                                         //mt:if %s.Field == HUDWorldPos
7557                                         WorldPos Pos
7558
7559                                         //mt:if %s.Field == HUDSize
7560                                         Size [2]int32
7561
7562                                         //mt:if %s.Field == HUDZIndex
7563                                         ZIndex int32
7564
7565                                         //mt:if %s.Field == HUDText2
7566                                         Text2 string
7567
7568                                         //mt:if %s.Field == HUDStyle
7569                                         Style HUDStyleFlags
7570                                 }))(obj)).Pos)[local172]
7571                                 write32(w, math.Float32bits(x))
7572                         }
7573                 }
7574         }
7575         if (*(*(struct {
7576                 ID HUDID
7577
7578                 Field HUDField
7579
7580                 //mt:if %s.Field == HUDPos
7581                 Pos [2]float32
7582
7583                 //mt:if %s.Field == HUDName
7584                 Name string
7585
7586                 //mt:if %s.Field == HUDScale
7587                 Scale [2]float32
7588
7589                 //mt:if %s.Field == HUDText
7590                 Text string
7591
7592                 //mt:if %s.Field == HUDNumber
7593                 Number uint32
7594
7595                 //mt:if %s.Field == HUDItem
7596                 Item uint32
7597
7598                 //mt:if %s.Field == HUDDir
7599                 Dir uint32
7600
7601                 //mt:if %s.Field == HUDAlign
7602                 Align [2]float32
7603
7604                 //mt:if %s.Field == HUDOffset
7605                 Offset [2]float32
7606
7607                 //mt:if %s.Field == HUDWorldPos
7608                 WorldPos Pos
7609
7610                 //mt:if %s.Field == HUDSize
7611                 Size [2]int32
7612
7613                 //mt:if %s.Field == HUDZIndex
7614                 ZIndex int32
7615
7616                 //mt:if %s.Field == HUDText2
7617                 Text2 string
7618
7619                 //mt:if %s.Field == HUDStyle
7620                 Style HUDStyleFlags
7621         }))(obj)).Field == HUDName {
7622                 if len(([]byte((*(*(struct {
7623                         ID HUDID
7624
7625                         Field HUDField
7626
7627                         //mt:if %s.Field == HUDPos
7628                         Pos [2]float32
7629
7630                         //mt:if %s.Field == HUDName
7631                         Name string
7632
7633                         //mt:if %s.Field == HUDScale
7634                         Scale [2]float32
7635
7636                         //mt:if %s.Field == HUDText
7637                         Text string
7638
7639                         //mt:if %s.Field == HUDNumber
7640                         Number uint32
7641
7642                         //mt:if %s.Field == HUDItem
7643                         Item uint32
7644
7645                         //mt:if %s.Field == HUDDir
7646                         Dir uint32
7647
7648                         //mt:if %s.Field == HUDAlign
7649                         Align [2]float32
7650
7651                         //mt:if %s.Field == HUDOffset
7652                         Offset [2]float32
7653
7654                         //mt:if %s.Field == HUDWorldPos
7655                         WorldPos Pos
7656
7657                         //mt:if %s.Field == HUDSize
7658                         Size [2]int32
7659
7660                         //mt:if %s.Field == HUDZIndex
7661                         ZIndex int32
7662
7663                         //mt:if %s.Field == HUDText2
7664                         Text2 string
7665
7666                         //mt:if %s.Field == HUDStyle
7667                         Style HUDStyleFlags
7668                 }))(obj)).Name))) > math.MaxUint16 {
7669                         chk(ErrTooLong)
7670                 }
7671                 {
7672                         x := uint16(len(([]byte((*(*(struct {
7673                                 ID HUDID
7674
7675                                 Field HUDField
7676
7677                                 //mt:if %s.Field == HUDPos
7678                                 Pos [2]float32
7679
7680                                 //mt:if %s.Field == HUDName
7681                                 Name string
7682
7683                                 //mt:if %s.Field == HUDScale
7684                                 Scale [2]float32
7685
7686                                 //mt:if %s.Field == HUDText
7687                                 Text string
7688
7689                                 //mt:if %s.Field == HUDNumber
7690                                 Number uint32
7691
7692                                 //mt:if %s.Field == HUDItem
7693                                 Item uint32
7694
7695                                 //mt:if %s.Field == HUDDir
7696                                 Dir uint32
7697
7698                                 //mt:if %s.Field == HUDAlign
7699                                 Align [2]float32
7700
7701                                 //mt:if %s.Field == HUDOffset
7702                                 Offset [2]float32
7703
7704                                 //mt:if %s.Field == HUDWorldPos
7705                                 WorldPos Pos
7706
7707                                 //mt:if %s.Field == HUDSize
7708                                 Size [2]int32
7709
7710                                 //mt:if %s.Field == HUDZIndex
7711                                 ZIndex int32
7712
7713                                 //mt:if %s.Field == HUDText2
7714                                 Text2 string
7715
7716                                 //mt:if %s.Field == HUDStyle
7717                                 Style HUDStyleFlags
7718                         }))(obj)).Name))))
7719                         write16(w, uint16(x))
7720                 }
7721                 {
7722                         _, err := w.Write(([]byte((*(*(struct {
7723                                 ID HUDID
7724
7725                                 Field HUDField
7726
7727                                 //mt:if %s.Field == HUDPos
7728                                 Pos [2]float32
7729
7730                                 //mt:if %s.Field == HUDName
7731                                 Name string
7732
7733                                 //mt:if %s.Field == HUDScale
7734                                 Scale [2]float32
7735
7736                                 //mt:if %s.Field == HUDText
7737                                 Text string
7738
7739                                 //mt:if %s.Field == HUDNumber
7740                                 Number uint32
7741
7742                                 //mt:if %s.Field == HUDItem
7743                                 Item uint32
7744
7745                                 //mt:if %s.Field == HUDDir
7746                                 Dir uint32
7747
7748                                 //mt:if %s.Field == HUDAlign
7749                                 Align [2]float32
7750
7751                                 //mt:if %s.Field == HUDOffset
7752                                 Offset [2]float32
7753
7754                                 //mt:if %s.Field == HUDWorldPos
7755                                 WorldPos Pos
7756
7757                                 //mt:if %s.Field == HUDSize
7758                                 Size [2]int32
7759
7760                                 //mt:if %s.Field == HUDZIndex
7761                                 ZIndex int32
7762
7763                                 //mt:if %s.Field == HUDText2
7764                                 Text2 string
7765
7766                                 //mt:if %s.Field == HUDStyle
7767                                 Style HUDStyleFlags
7768                         }))(obj)).Name))[:])
7769                         chk(err)
7770                 }
7771         }
7772         if (*(*(struct {
7773                 ID HUDID
7774
7775                 Field HUDField
7776
7777                 //mt:if %s.Field == HUDPos
7778                 Pos [2]float32
7779
7780                 //mt:if %s.Field == HUDName
7781                 Name string
7782
7783                 //mt:if %s.Field == HUDScale
7784                 Scale [2]float32
7785
7786                 //mt:if %s.Field == HUDText
7787                 Text string
7788
7789                 //mt:if %s.Field == HUDNumber
7790                 Number uint32
7791
7792                 //mt:if %s.Field == HUDItem
7793                 Item uint32
7794
7795                 //mt:if %s.Field == HUDDir
7796                 Dir uint32
7797
7798                 //mt:if %s.Field == HUDAlign
7799                 Align [2]float32
7800
7801                 //mt:if %s.Field == HUDOffset
7802                 Offset [2]float32
7803
7804                 //mt:if %s.Field == HUDWorldPos
7805                 WorldPos Pos
7806
7807                 //mt:if %s.Field == HUDSize
7808                 Size [2]int32
7809
7810                 //mt:if %s.Field == HUDZIndex
7811                 ZIndex int32
7812
7813                 //mt:if %s.Field == HUDText2
7814                 Text2 string
7815
7816                 //mt:if %s.Field == HUDStyle
7817                 Style HUDStyleFlags
7818         }))(obj)).Field == HUDScale {
7819                 for local173 := range (*(*(struct {
7820                         ID HUDID
7821
7822                         Field HUDField
7823
7824                         //mt:if %s.Field == HUDPos
7825                         Pos [2]float32
7826
7827                         //mt:if %s.Field == HUDName
7828                         Name string
7829
7830                         //mt:if %s.Field == HUDScale
7831                         Scale [2]float32
7832
7833                         //mt:if %s.Field == HUDText
7834                         Text string
7835
7836                         //mt:if %s.Field == HUDNumber
7837                         Number uint32
7838
7839                         //mt:if %s.Field == HUDItem
7840                         Item uint32
7841
7842                         //mt:if %s.Field == HUDDir
7843                         Dir uint32
7844
7845                         //mt:if %s.Field == HUDAlign
7846                         Align [2]float32
7847
7848                         //mt:if %s.Field == HUDOffset
7849                         Offset [2]float32
7850
7851                         //mt:if %s.Field == HUDWorldPos
7852                         WorldPos Pos
7853
7854                         //mt:if %s.Field == HUDSize
7855                         Size [2]int32
7856
7857                         //mt:if %s.Field == HUDZIndex
7858                         ZIndex int32
7859
7860                         //mt:if %s.Field == HUDText2
7861                         Text2 string
7862
7863                         //mt:if %s.Field == HUDStyle
7864                         Style HUDStyleFlags
7865                 }))(obj)).Scale {
7866                         {
7867                                 x := ((*(*(struct {
7868                                         ID HUDID
7869
7870                                         Field HUDField
7871
7872                                         //mt:if %s.Field == HUDPos
7873                                         Pos [2]float32
7874
7875                                         //mt:if %s.Field == HUDName
7876                                         Name string
7877
7878                                         //mt:if %s.Field == HUDScale
7879                                         Scale [2]float32
7880
7881                                         //mt:if %s.Field == HUDText
7882                                         Text string
7883
7884                                         //mt:if %s.Field == HUDNumber
7885                                         Number uint32
7886
7887                                         //mt:if %s.Field == HUDItem
7888                                         Item uint32
7889
7890                                         //mt:if %s.Field == HUDDir
7891                                         Dir uint32
7892
7893                                         //mt:if %s.Field == HUDAlign
7894                                         Align [2]float32
7895
7896                                         //mt:if %s.Field == HUDOffset
7897                                         Offset [2]float32
7898
7899                                         //mt:if %s.Field == HUDWorldPos
7900                                         WorldPos Pos
7901
7902                                         //mt:if %s.Field == HUDSize
7903                                         Size [2]int32
7904
7905                                         //mt:if %s.Field == HUDZIndex
7906                                         ZIndex int32
7907
7908                                         //mt:if %s.Field == HUDText2
7909                                         Text2 string
7910
7911                                         //mt:if %s.Field == HUDStyle
7912                                         Style HUDStyleFlags
7913                                 }))(obj)).Scale)[local173]
7914                                 write32(w, math.Float32bits(x))
7915                         }
7916                 }
7917         }
7918         if (*(*(struct {
7919                 ID HUDID
7920
7921                 Field HUDField
7922
7923                 //mt:if %s.Field == HUDPos
7924                 Pos [2]float32
7925
7926                 //mt:if %s.Field == HUDName
7927                 Name string
7928
7929                 //mt:if %s.Field == HUDScale
7930                 Scale [2]float32
7931
7932                 //mt:if %s.Field == HUDText
7933                 Text string
7934
7935                 //mt:if %s.Field == HUDNumber
7936                 Number uint32
7937
7938                 //mt:if %s.Field == HUDItem
7939                 Item uint32
7940
7941                 //mt:if %s.Field == HUDDir
7942                 Dir uint32
7943
7944                 //mt:if %s.Field == HUDAlign
7945                 Align [2]float32
7946
7947                 //mt:if %s.Field == HUDOffset
7948                 Offset [2]float32
7949
7950                 //mt:if %s.Field == HUDWorldPos
7951                 WorldPos Pos
7952
7953                 //mt:if %s.Field == HUDSize
7954                 Size [2]int32
7955
7956                 //mt:if %s.Field == HUDZIndex
7957                 ZIndex int32
7958
7959                 //mt:if %s.Field == HUDText2
7960                 Text2 string
7961
7962                 //mt:if %s.Field == HUDStyle
7963                 Style HUDStyleFlags
7964         }))(obj)).Field == HUDText {
7965                 if len(([]byte((*(*(struct {
7966                         ID HUDID
7967
7968                         Field HUDField
7969
7970                         //mt:if %s.Field == HUDPos
7971                         Pos [2]float32
7972
7973                         //mt:if %s.Field == HUDName
7974                         Name string
7975
7976                         //mt:if %s.Field == HUDScale
7977                         Scale [2]float32
7978
7979                         //mt:if %s.Field == HUDText
7980                         Text string
7981
7982                         //mt:if %s.Field == HUDNumber
7983                         Number uint32
7984
7985                         //mt:if %s.Field == HUDItem
7986                         Item uint32
7987
7988                         //mt:if %s.Field == HUDDir
7989                         Dir uint32
7990
7991                         //mt:if %s.Field == HUDAlign
7992                         Align [2]float32
7993
7994                         //mt:if %s.Field == HUDOffset
7995                         Offset [2]float32
7996
7997                         //mt:if %s.Field == HUDWorldPos
7998                         WorldPos Pos
7999
8000                         //mt:if %s.Field == HUDSize
8001                         Size [2]int32
8002
8003                         //mt:if %s.Field == HUDZIndex
8004                         ZIndex int32
8005
8006                         //mt:if %s.Field == HUDText2
8007                         Text2 string
8008
8009                         //mt:if %s.Field == HUDStyle
8010                         Style HUDStyleFlags
8011                 }))(obj)).Text))) > math.MaxUint16 {
8012                         chk(ErrTooLong)
8013                 }
8014                 {
8015                         x := uint16(len(([]byte((*(*(struct {
8016                                 ID HUDID
8017
8018                                 Field HUDField
8019
8020                                 //mt:if %s.Field == HUDPos
8021                                 Pos [2]float32
8022
8023                                 //mt:if %s.Field == HUDName
8024                                 Name string
8025
8026                                 //mt:if %s.Field == HUDScale
8027                                 Scale [2]float32
8028
8029                                 //mt:if %s.Field == HUDText
8030                                 Text string
8031
8032                                 //mt:if %s.Field == HUDNumber
8033                                 Number uint32
8034
8035                                 //mt:if %s.Field == HUDItem
8036                                 Item uint32
8037
8038                                 //mt:if %s.Field == HUDDir
8039                                 Dir uint32
8040
8041                                 //mt:if %s.Field == HUDAlign
8042                                 Align [2]float32
8043
8044                                 //mt:if %s.Field == HUDOffset
8045                                 Offset [2]float32
8046
8047                                 //mt:if %s.Field == HUDWorldPos
8048                                 WorldPos Pos
8049
8050                                 //mt:if %s.Field == HUDSize
8051                                 Size [2]int32
8052
8053                                 //mt:if %s.Field == HUDZIndex
8054                                 ZIndex int32
8055
8056                                 //mt:if %s.Field == HUDText2
8057                                 Text2 string
8058
8059                                 //mt:if %s.Field == HUDStyle
8060                                 Style HUDStyleFlags
8061                         }))(obj)).Text))))
8062                         write16(w, uint16(x))
8063                 }
8064                 {
8065                         _, err := w.Write(([]byte((*(*(struct {
8066                                 ID HUDID
8067
8068                                 Field HUDField
8069
8070                                 //mt:if %s.Field == HUDPos
8071                                 Pos [2]float32
8072
8073                                 //mt:if %s.Field == HUDName
8074                                 Name string
8075
8076                                 //mt:if %s.Field == HUDScale
8077                                 Scale [2]float32
8078
8079                                 //mt:if %s.Field == HUDText
8080                                 Text string
8081
8082                                 //mt:if %s.Field == HUDNumber
8083                                 Number uint32
8084
8085                                 //mt:if %s.Field == HUDItem
8086                                 Item uint32
8087
8088                                 //mt:if %s.Field == HUDDir
8089                                 Dir uint32
8090
8091                                 //mt:if %s.Field == HUDAlign
8092                                 Align [2]float32
8093
8094                                 //mt:if %s.Field == HUDOffset
8095                                 Offset [2]float32
8096
8097                                 //mt:if %s.Field == HUDWorldPos
8098                                 WorldPos Pos
8099
8100                                 //mt:if %s.Field == HUDSize
8101                                 Size [2]int32
8102
8103                                 //mt:if %s.Field == HUDZIndex
8104                                 ZIndex int32
8105
8106                                 //mt:if %s.Field == HUDText2
8107                                 Text2 string
8108
8109                                 //mt:if %s.Field == HUDStyle
8110                                 Style HUDStyleFlags
8111                         }))(obj)).Text))[:])
8112                         chk(err)
8113                 }
8114         }
8115         if (*(*(struct {
8116                 ID HUDID
8117
8118                 Field HUDField
8119
8120                 //mt:if %s.Field == HUDPos
8121                 Pos [2]float32
8122
8123                 //mt:if %s.Field == HUDName
8124                 Name string
8125
8126                 //mt:if %s.Field == HUDScale
8127                 Scale [2]float32
8128
8129                 //mt:if %s.Field == HUDText
8130                 Text string
8131
8132                 //mt:if %s.Field == HUDNumber
8133                 Number uint32
8134
8135                 //mt:if %s.Field == HUDItem
8136                 Item uint32
8137
8138                 //mt:if %s.Field == HUDDir
8139                 Dir uint32
8140
8141                 //mt:if %s.Field == HUDAlign
8142                 Align [2]float32
8143
8144                 //mt:if %s.Field == HUDOffset
8145                 Offset [2]float32
8146
8147                 //mt:if %s.Field == HUDWorldPos
8148                 WorldPos Pos
8149
8150                 //mt:if %s.Field == HUDSize
8151                 Size [2]int32
8152
8153                 //mt:if %s.Field == HUDZIndex
8154                 ZIndex int32
8155
8156                 //mt:if %s.Field == HUDText2
8157                 Text2 string
8158
8159                 //mt:if %s.Field == HUDStyle
8160                 Style HUDStyleFlags
8161         }))(obj)).Field == HUDNumber {
8162                 {
8163                         x := (*(*(struct {
8164                                 ID HUDID
8165
8166                                 Field HUDField
8167
8168                                 //mt:if %s.Field == HUDPos
8169                                 Pos [2]float32
8170
8171                                 //mt:if %s.Field == HUDName
8172                                 Name string
8173
8174                                 //mt:if %s.Field == HUDScale
8175                                 Scale [2]float32
8176
8177                                 //mt:if %s.Field == HUDText
8178                                 Text string
8179
8180                                 //mt:if %s.Field == HUDNumber
8181                                 Number uint32
8182
8183                                 //mt:if %s.Field == HUDItem
8184                                 Item uint32
8185
8186                                 //mt:if %s.Field == HUDDir
8187                                 Dir uint32
8188
8189                                 //mt:if %s.Field == HUDAlign
8190                                 Align [2]float32
8191
8192                                 //mt:if %s.Field == HUDOffset
8193                                 Offset [2]float32
8194
8195                                 //mt:if %s.Field == HUDWorldPos
8196                                 WorldPos Pos
8197
8198                                 //mt:if %s.Field == HUDSize
8199                                 Size [2]int32
8200
8201                                 //mt:if %s.Field == HUDZIndex
8202                                 ZIndex int32
8203
8204                                 //mt:if %s.Field == HUDText2
8205                                 Text2 string
8206
8207                                 //mt:if %s.Field == HUDStyle
8208                                 Style HUDStyleFlags
8209                         }))(obj)).Number
8210                         write32(w, uint32(x))
8211                 }
8212         }
8213         if (*(*(struct {
8214                 ID HUDID
8215
8216                 Field HUDField
8217
8218                 //mt:if %s.Field == HUDPos
8219                 Pos [2]float32
8220
8221                 //mt:if %s.Field == HUDName
8222                 Name string
8223
8224                 //mt:if %s.Field == HUDScale
8225                 Scale [2]float32
8226
8227                 //mt:if %s.Field == HUDText
8228                 Text string
8229
8230                 //mt:if %s.Field == HUDNumber
8231                 Number uint32
8232
8233                 //mt:if %s.Field == HUDItem
8234                 Item uint32
8235
8236                 //mt:if %s.Field == HUDDir
8237                 Dir uint32
8238
8239                 //mt:if %s.Field == HUDAlign
8240                 Align [2]float32
8241
8242                 //mt:if %s.Field == HUDOffset
8243                 Offset [2]float32
8244
8245                 //mt:if %s.Field == HUDWorldPos
8246                 WorldPos Pos
8247
8248                 //mt:if %s.Field == HUDSize
8249                 Size [2]int32
8250
8251                 //mt:if %s.Field == HUDZIndex
8252                 ZIndex int32
8253
8254                 //mt:if %s.Field == HUDText2
8255                 Text2 string
8256
8257                 //mt:if %s.Field == HUDStyle
8258                 Style HUDStyleFlags
8259         }))(obj)).Field == HUDItem {
8260                 {
8261                         x := (*(*(struct {
8262                                 ID HUDID
8263
8264                                 Field HUDField
8265
8266                                 //mt:if %s.Field == HUDPos
8267                                 Pos [2]float32
8268
8269                                 //mt:if %s.Field == HUDName
8270                                 Name string
8271
8272                                 //mt:if %s.Field == HUDScale
8273                                 Scale [2]float32
8274
8275                                 //mt:if %s.Field == HUDText
8276                                 Text string
8277
8278                                 //mt:if %s.Field == HUDNumber
8279                                 Number uint32
8280
8281                                 //mt:if %s.Field == HUDItem
8282                                 Item uint32
8283
8284                                 //mt:if %s.Field == HUDDir
8285                                 Dir uint32
8286
8287                                 //mt:if %s.Field == HUDAlign
8288                                 Align [2]float32
8289
8290                                 //mt:if %s.Field == HUDOffset
8291                                 Offset [2]float32
8292
8293                                 //mt:if %s.Field == HUDWorldPos
8294                                 WorldPos Pos
8295
8296                                 //mt:if %s.Field == HUDSize
8297                                 Size [2]int32
8298
8299                                 //mt:if %s.Field == HUDZIndex
8300                                 ZIndex int32
8301
8302                                 //mt:if %s.Field == HUDText2
8303                                 Text2 string
8304
8305                                 //mt:if %s.Field == HUDStyle
8306                                 Style HUDStyleFlags
8307                         }))(obj)).Item
8308                         write32(w, uint32(x))
8309                 }
8310         }
8311         if (*(*(struct {
8312                 ID HUDID
8313
8314                 Field HUDField
8315
8316                 //mt:if %s.Field == HUDPos
8317                 Pos [2]float32
8318
8319                 //mt:if %s.Field == HUDName
8320                 Name string
8321
8322                 //mt:if %s.Field == HUDScale
8323                 Scale [2]float32
8324
8325                 //mt:if %s.Field == HUDText
8326                 Text string
8327
8328                 //mt:if %s.Field == HUDNumber
8329                 Number uint32
8330
8331                 //mt:if %s.Field == HUDItem
8332                 Item uint32
8333
8334                 //mt:if %s.Field == HUDDir
8335                 Dir uint32
8336
8337                 //mt:if %s.Field == HUDAlign
8338                 Align [2]float32
8339
8340                 //mt:if %s.Field == HUDOffset
8341                 Offset [2]float32
8342
8343                 //mt:if %s.Field == HUDWorldPos
8344                 WorldPos Pos
8345
8346                 //mt:if %s.Field == HUDSize
8347                 Size [2]int32
8348
8349                 //mt:if %s.Field == HUDZIndex
8350                 ZIndex int32
8351
8352                 //mt:if %s.Field == HUDText2
8353                 Text2 string
8354
8355                 //mt:if %s.Field == HUDStyle
8356                 Style HUDStyleFlags
8357         }))(obj)).Field == HUDDir {
8358                 {
8359                         x := (*(*(struct {
8360                                 ID HUDID
8361
8362                                 Field HUDField
8363
8364                                 //mt:if %s.Field == HUDPos
8365                                 Pos [2]float32
8366
8367                                 //mt:if %s.Field == HUDName
8368                                 Name string
8369
8370                                 //mt:if %s.Field == HUDScale
8371                                 Scale [2]float32
8372
8373                                 //mt:if %s.Field == HUDText
8374                                 Text string
8375
8376                                 //mt:if %s.Field == HUDNumber
8377                                 Number uint32
8378
8379                                 //mt:if %s.Field == HUDItem
8380                                 Item uint32
8381
8382                                 //mt:if %s.Field == HUDDir
8383                                 Dir uint32
8384
8385                                 //mt:if %s.Field == HUDAlign
8386                                 Align [2]float32
8387
8388                                 //mt:if %s.Field == HUDOffset
8389                                 Offset [2]float32
8390
8391                                 //mt:if %s.Field == HUDWorldPos
8392                                 WorldPos Pos
8393
8394                                 //mt:if %s.Field == HUDSize
8395                                 Size [2]int32
8396
8397                                 //mt:if %s.Field == HUDZIndex
8398                                 ZIndex int32
8399
8400                                 //mt:if %s.Field == HUDText2
8401                                 Text2 string
8402
8403                                 //mt:if %s.Field == HUDStyle
8404                                 Style HUDStyleFlags
8405                         }))(obj)).Dir
8406                         write32(w, uint32(x))
8407                 }
8408         }
8409         if (*(*(struct {
8410                 ID HUDID
8411
8412                 Field HUDField
8413
8414                 //mt:if %s.Field == HUDPos
8415                 Pos [2]float32
8416
8417                 //mt:if %s.Field == HUDName
8418                 Name string
8419
8420                 //mt:if %s.Field == HUDScale
8421                 Scale [2]float32
8422
8423                 //mt:if %s.Field == HUDText
8424                 Text string
8425
8426                 //mt:if %s.Field == HUDNumber
8427                 Number uint32
8428
8429                 //mt:if %s.Field == HUDItem
8430                 Item uint32
8431
8432                 //mt:if %s.Field == HUDDir
8433                 Dir uint32
8434
8435                 //mt:if %s.Field == HUDAlign
8436                 Align [2]float32
8437
8438                 //mt:if %s.Field == HUDOffset
8439                 Offset [2]float32
8440
8441                 //mt:if %s.Field == HUDWorldPos
8442                 WorldPos Pos
8443
8444                 //mt:if %s.Field == HUDSize
8445                 Size [2]int32
8446
8447                 //mt:if %s.Field == HUDZIndex
8448                 ZIndex int32
8449
8450                 //mt:if %s.Field == HUDText2
8451                 Text2 string
8452
8453                 //mt:if %s.Field == HUDStyle
8454                 Style HUDStyleFlags
8455         }))(obj)).Field == HUDAlign {
8456                 for local174 := range (*(*(struct {
8457                         ID HUDID
8458
8459                         Field HUDField
8460
8461                         //mt:if %s.Field == HUDPos
8462                         Pos [2]float32
8463
8464                         //mt:if %s.Field == HUDName
8465                         Name string
8466
8467                         //mt:if %s.Field == HUDScale
8468                         Scale [2]float32
8469
8470                         //mt:if %s.Field == HUDText
8471                         Text string
8472
8473                         //mt:if %s.Field == HUDNumber
8474                         Number uint32
8475
8476                         //mt:if %s.Field == HUDItem
8477                         Item uint32
8478
8479                         //mt:if %s.Field == HUDDir
8480                         Dir uint32
8481
8482                         //mt:if %s.Field == HUDAlign
8483                         Align [2]float32
8484
8485                         //mt:if %s.Field == HUDOffset
8486                         Offset [2]float32
8487
8488                         //mt:if %s.Field == HUDWorldPos
8489                         WorldPos Pos
8490
8491                         //mt:if %s.Field == HUDSize
8492                         Size [2]int32
8493
8494                         //mt:if %s.Field == HUDZIndex
8495                         ZIndex int32
8496
8497                         //mt:if %s.Field == HUDText2
8498                         Text2 string
8499
8500                         //mt:if %s.Field == HUDStyle
8501                         Style HUDStyleFlags
8502                 }))(obj)).Align {
8503                         {
8504                                 x := ((*(*(struct {
8505                                         ID HUDID
8506
8507                                         Field HUDField
8508
8509                                         //mt:if %s.Field == HUDPos
8510                                         Pos [2]float32
8511
8512                                         //mt:if %s.Field == HUDName
8513                                         Name string
8514
8515                                         //mt:if %s.Field == HUDScale
8516                                         Scale [2]float32
8517
8518                                         //mt:if %s.Field == HUDText
8519                                         Text string
8520
8521                                         //mt:if %s.Field == HUDNumber
8522                                         Number uint32
8523
8524                                         //mt:if %s.Field == HUDItem
8525                                         Item uint32
8526
8527                                         //mt:if %s.Field == HUDDir
8528                                         Dir uint32
8529
8530                                         //mt:if %s.Field == HUDAlign
8531                                         Align [2]float32
8532
8533                                         //mt:if %s.Field == HUDOffset
8534                                         Offset [2]float32
8535
8536                                         //mt:if %s.Field == HUDWorldPos
8537                                         WorldPos Pos
8538
8539                                         //mt:if %s.Field == HUDSize
8540                                         Size [2]int32
8541
8542                                         //mt:if %s.Field == HUDZIndex
8543                                         ZIndex int32
8544
8545                                         //mt:if %s.Field == HUDText2
8546                                         Text2 string
8547
8548                                         //mt:if %s.Field == HUDStyle
8549                                         Style HUDStyleFlags
8550                                 }))(obj)).Align)[local174]
8551                                 write32(w, math.Float32bits(x))
8552                         }
8553                 }
8554         }
8555         if (*(*(struct {
8556                 ID HUDID
8557
8558                 Field HUDField
8559
8560                 //mt:if %s.Field == HUDPos
8561                 Pos [2]float32
8562
8563                 //mt:if %s.Field == HUDName
8564                 Name string
8565
8566                 //mt:if %s.Field == HUDScale
8567                 Scale [2]float32
8568
8569                 //mt:if %s.Field == HUDText
8570                 Text string
8571
8572                 //mt:if %s.Field == HUDNumber
8573                 Number uint32
8574
8575                 //mt:if %s.Field == HUDItem
8576                 Item uint32
8577
8578                 //mt:if %s.Field == HUDDir
8579                 Dir uint32
8580
8581                 //mt:if %s.Field == HUDAlign
8582                 Align [2]float32
8583
8584                 //mt:if %s.Field == HUDOffset
8585                 Offset [2]float32
8586
8587                 //mt:if %s.Field == HUDWorldPos
8588                 WorldPos Pos
8589
8590                 //mt:if %s.Field == HUDSize
8591                 Size [2]int32
8592
8593                 //mt:if %s.Field == HUDZIndex
8594                 ZIndex int32
8595
8596                 //mt:if %s.Field == HUDText2
8597                 Text2 string
8598
8599                 //mt:if %s.Field == HUDStyle
8600                 Style HUDStyleFlags
8601         }))(obj)).Field == HUDOffset {
8602                 for local175 := range (*(*(struct {
8603                         ID HUDID
8604
8605                         Field HUDField
8606
8607                         //mt:if %s.Field == HUDPos
8608                         Pos [2]float32
8609
8610                         //mt:if %s.Field == HUDName
8611                         Name string
8612
8613                         //mt:if %s.Field == HUDScale
8614                         Scale [2]float32
8615
8616                         //mt:if %s.Field == HUDText
8617                         Text string
8618
8619                         //mt:if %s.Field == HUDNumber
8620                         Number uint32
8621
8622                         //mt:if %s.Field == HUDItem
8623                         Item uint32
8624
8625                         //mt:if %s.Field == HUDDir
8626                         Dir uint32
8627
8628                         //mt:if %s.Field == HUDAlign
8629                         Align [2]float32
8630
8631                         //mt:if %s.Field == HUDOffset
8632                         Offset [2]float32
8633
8634                         //mt:if %s.Field == HUDWorldPos
8635                         WorldPos Pos
8636
8637                         //mt:if %s.Field == HUDSize
8638                         Size [2]int32
8639
8640                         //mt:if %s.Field == HUDZIndex
8641                         ZIndex int32
8642
8643                         //mt:if %s.Field == HUDText2
8644                         Text2 string
8645
8646                         //mt:if %s.Field == HUDStyle
8647                         Style HUDStyleFlags
8648                 }))(obj)).Offset {
8649                         {
8650                                 x := ((*(*(struct {
8651                                         ID HUDID
8652
8653                                         Field HUDField
8654
8655                                         //mt:if %s.Field == HUDPos
8656                                         Pos [2]float32
8657
8658                                         //mt:if %s.Field == HUDName
8659                                         Name string
8660
8661                                         //mt:if %s.Field == HUDScale
8662                                         Scale [2]float32
8663
8664                                         //mt:if %s.Field == HUDText
8665                                         Text string
8666
8667                                         //mt:if %s.Field == HUDNumber
8668                                         Number uint32
8669
8670                                         //mt:if %s.Field == HUDItem
8671                                         Item uint32
8672
8673                                         //mt:if %s.Field == HUDDir
8674                                         Dir uint32
8675
8676                                         //mt:if %s.Field == HUDAlign
8677                                         Align [2]float32
8678
8679                                         //mt:if %s.Field == HUDOffset
8680                                         Offset [2]float32
8681
8682                                         //mt:if %s.Field == HUDWorldPos
8683                                         WorldPos Pos
8684
8685                                         //mt:if %s.Field == HUDSize
8686                                         Size [2]int32
8687
8688                                         //mt:if %s.Field == HUDZIndex
8689                                         ZIndex int32
8690
8691                                         //mt:if %s.Field == HUDText2
8692                                         Text2 string
8693
8694                                         //mt:if %s.Field == HUDStyle
8695                                         Style HUDStyleFlags
8696                                 }))(obj)).Offset)[local175]
8697                                 write32(w, math.Float32bits(x))
8698                         }
8699                 }
8700         }
8701         if (*(*(struct {
8702                 ID HUDID
8703
8704                 Field HUDField
8705
8706                 //mt:if %s.Field == HUDPos
8707                 Pos [2]float32
8708
8709                 //mt:if %s.Field == HUDName
8710                 Name string
8711
8712                 //mt:if %s.Field == HUDScale
8713                 Scale [2]float32
8714
8715                 //mt:if %s.Field == HUDText
8716                 Text string
8717
8718                 //mt:if %s.Field == HUDNumber
8719                 Number uint32
8720
8721                 //mt:if %s.Field == HUDItem
8722                 Item uint32
8723
8724                 //mt:if %s.Field == HUDDir
8725                 Dir uint32
8726
8727                 //mt:if %s.Field == HUDAlign
8728                 Align [2]float32
8729
8730                 //mt:if %s.Field == HUDOffset
8731                 Offset [2]float32
8732
8733                 //mt:if %s.Field == HUDWorldPos
8734                 WorldPos Pos
8735
8736                 //mt:if %s.Field == HUDSize
8737                 Size [2]int32
8738
8739                 //mt:if %s.Field == HUDZIndex
8740                 ZIndex int32
8741
8742                 //mt:if %s.Field == HUDText2
8743                 Text2 string
8744
8745                 //mt:if %s.Field == HUDStyle
8746                 Style HUDStyleFlags
8747         }))(obj)).Field == HUDWorldPos {
8748                 if err := pcall(func() {
8749                         ((*(*(struct {
8750                                 ID HUDID
8751
8752                                 Field HUDField
8753
8754                                 //mt:if %s.Field == HUDPos
8755                                 Pos [2]float32
8756
8757                                 //mt:if %s.Field == HUDName
8758                                 Name string
8759
8760                                 //mt:if %s.Field == HUDScale
8761                                 Scale [2]float32
8762
8763                                 //mt:if %s.Field == HUDText
8764                                 Text string
8765
8766                                 //mt:if %s.Field == HUDNumber
8767                                 Number uint32
8768
8769                                 //mt:if %s.Field == HUDItem
8770                                 Item uint32
8771
8772                                 //mt:if %s.Field == HUDDir
8773                                 Dir uint32
8774
8775                                 //mt:if %s.Field == HUDAlign
8776                                 Align [2]float32
8777
8778                                 //mt:if %s.Field == HUDOffset
8779                                 Offset [2]float32
8780
8781                                 //mt:if %s.Field == HUDWorldPos
8782                                 WorldPos Pos
8783
8784                                 //mt:if %s.Field == HUDSize
8785                                 Size [2]int32
8786
8787                                 //mt:if %s.Field == HUDZIndex
8788                                 ZIndex int32
8789
8790                                 //mt:if %s.Field == HUDText2
8791                                 Text2 string
8792
8793                                 //mt:if %s.Field == HUDStyle
8794                                 Style HUDStyleFlags
8795                         }))(obj)).WorldPos).serialize(w)
8796                 }); err != nil {
8797                         if err == io.EOF {
8798                                 chk(io.EOF)
8799                         }
8800                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
8801                 }
8802         }
8803         if (*(*(struct {
8804                 ID HUDID
8805
8806                 Field HUDField
8807
8808                 //mt:if %s.Field == HUDPos
8809                 Pos [2]float32
8810
8811                 //mt:if %s.Field == HUDName
8812                 Name string
8813
8814                 //mt:if %s.Field == HUDScale
8815                 Scale [2]float32
8816
8817                 //mt:if %s.Field == HUDText
8818                 Text string
8819
8820                 //mt:if %s.Field == HUDNumber
8821                 Number uint32
8822
8823                 //mt:if %s.Field == HUDItem
8824                 Item uint32
8825
8826                 //mt:if %s.Field == HUDDir
8827                 Dir uint32
8828
8829                 //mt:if %s.Field == HUDAlign
8830                 Align [2]float32
8831
8832                 //mt:if %s.Field == HUDOffset
8833                 Offset [2]float32
8834
8835                 //mt:if %s.Field == HUDWorldPos
8836                 WorldPos Pos
8837
8838                 //mt:if %s.Field == HUDSize
8839                 Size [2]int32
8840
8841                 //mt:if %s.Field == HUDZIndex
8842                 ZIndex int32
8843
8844                 //mt:if %s.Field == HUDText2
8845                 Text2 string
8846
8847                 //mt:if %s.Field == HUDStyle
8848                 Style HUDStyleFlags
8849         }))(obj)).Field == HUDSize {
8850                 for local176 := range (*(*(struct {
8851                         ID HUDID
8852
8853                         Field HUDField
8854
8855                         //mt:if %s.Field == HUDPos
8856                         Pos [2]float32
8857
8858                         //mt:if %s.Field == HUDName
8859                         Name string
8860
8861                         //mt:if %s.Field == HUDScale
8862                         Scale [2]float32
8863
8864                         //mt:if %s.Field == HUDText
8865                         Text string
8866
8867                         //mt:if %s.Field == HUDNumber
8868                         Number uint32
8869
8870                         //mt:if %s.Field == HUDItem
8871                         Item uint32
8872
8873                         //mt:if %s.Field == HUDDir
8874                         Dir uint32
8875
8876                         //mt:if %s.Field == HUDAlign
8877                         Align [2]float32
8878
8879                         //mt:if %s.Field == HUDOffset
8880                         Offset [2]float32
8881
8882                         //mt:if %s.Field == HUDWorldPos
8883                         WorldPos Pos
8884
8885                         //mt:if %s.Field == HUDSize
8886                         Size [2]int32
8887
8888                         //mt:if %s.Field == HUDZIndex
8889                         ZIndex int32
8890
8891                         //mt:if %s.Field == HUDText2
8892                         Text2 string
8893
8894                         //mt:if %s.Field == HUDStyle
8895                         Style HUDStyleFlags
8896                 }))(obj)).Size {
8897                         {
8898                                 x := ((*(*(struct {
8899                                         ID HUDID
8900
8901                                         Field HUDField
8902
8903                                         //mt:if %s.Field == HUDPos
8904                                         Pos [2]float32
8905
8906                                         //mt:if %s.Field == HUDName
8907                                         Name string
8908
8909                                         //mt:if %s.Field == HUDScale
8910                                         Scale [2]float32
8911
8912                                         //mt:if %s.Field == HUDText
8913                                         Text string
8914
8915                                         //mt:if %s.Field == HUDNumber
8916                                         Number uint32
8917
8918                                         //mt:if %s.Field == HUDItem
8919                                         Item uint32
8920
8921                                         //mt:if %s.Field == HUDDir
8922                                         Dir uint32
8923
8924                                         //mt:if %s.Field == HUDAlign
8925                                         Align [2]float32
8926
8927                                         //mt:if %s.Field == HUDOffset
8928                                         Offset [2]float32
8929
8930                                         //mt:if %s.Field == HUDWorldPos
8931                                         WorldPos Pos
8932
8933                                         //mt:if %s.Field == HUDSize
8934                                         Size [2]int32
8935
8936                                         //mt:if %s.Field == HUDZIndex
8937                                         ZIndex int32
8938
8939                                         //mt:if %s.Field == HUDText2
8940                                         Text2 string
8941
8942                                         //mt:if %s.Field == HUDStyle
8943                                         Style HUDStyleFlags
8944                                 }))(obj)).Size)[local176]
8945                                 write32(w, uint32(x))
8946                         }
8947                 }
8948         }
8949         if (*(*(struct {
8950                 ID HUDID
8951
8952                 Field HUDField
8953
8954                 //mt:if %s.Field == HUDPos
8955                 Pos [2]float32
8956
8957                 //mt:if %s.Field == HUDName
8958                 Name string
8959
8960                 //mt:if %s.Field == HUDScale
8961                 Scale [2]float32
8962
8963                 //mt:if %s.Field == HUDText
8964                 Text string
8965
8966                 //mt:if %s.Field == HUDNumber
8967                 Number uint32
8968
8969                 //mt:if %s.Field == HUDItem
8970                 Item uint32
8971
8972                 //mt:if %s.Field == HUDDir
8973                 Dir uint32
8974
8975                 //mt:if %s.Field == HUDAlign
8976                 Align [2]float32
8977
8978                 //mt:if %s.Field == HUDOffset
8979                 Offset [2]float32
8980
8981                 //mt:if %s.Field == HUDWorldPos
8982                 WorldPos Pos
8983
8984                 //mt:if %s.Field == HUDSize
8985                 Size [2]int32
8986
8987                 //mt:if %s.Field == HUDZIndex
8988                 ZIndex int32
8989
8990                 //mt:if %s.Field == HUDText2
8991                 Text2 string
8992
8993                 //mt:if %s.Field == HUDStyle
8994                 Style HUDStyleFlags
8995         }))(obj)).Field == HUDZIndex {
8996                 {
8997                         x := (*(*(struct {
8998                                 ID HUDID
8999
9000                                 Field HUDField
9001
9002                                 //mt:if %s.Field == HUDPos
9003                                 Pos [2]float32
9004
9005                                 //mt:if %s.Field == HUDName
9006                                 Name string
9007
9008                                 //mt:if %s.Field == HUDScale
9009                                 Scale [2]float32
9010
9011                                 //mt:if %s.Field == HUDText
9012                                 Text string
9013
9014                                 //mt:if %s.Field == HUDNumber
9015                                 Number uint32
9016
9017                                 //mt:if %s.Field == HUDItem
9018                                 Item uint32
9019
9020                                 //mt:if %s.Field == HUDDir
9021                                 Dir uint32
9022
9023                                 //mt:if %s.Field == HUDAlign
9024                                 Align [2]float32
9025
9026                                 //mt:if %s.Field == HUDOffset
9027                                 Offset [2]float32
9028
9029                                 //mt:if %s.Field == HUDWorldPos
9030                                 WorldPos Pos
9031
9032                                 //mt:if %s.Field == HUDSize
9033                                 Size [2]int32
9034
9035                                 //mt:if %s.Field == HUDZIndex
9036                                 ZIndex int32
9037
9038                                 //mt:if %s.Field == HUDText2
9039                                 Text2 string
9040
9041                                 //mt:if %s.Field == HUDStyle
9042                                 Style HUDStyleFlags
9043                         }))(obj)).ZIndex
9044                         write32(w, uint32(x))
9045                 }
9046         }
9047         if (*(*(struct {
9048                 ID HUDID
9049
9050                 Field HUDField
9051
9052                 //mt:if %s.Field == HUDPos
9053                 Pos [2]float32
9054
9055                 //mt:if %s.Field == HUDName
9056                 Name string
9057
9058                 //mt:if %s.Field == HUDScale
9059                 Scale [2]float32
9060
9061                 //mt:if %s.Field == HUDText
9062                 Text string
9063
9064                 //mt:if %s.Field == HUDNumber
9065                 Number uint32
9066
9067                 //mt:if %s.Field == HUDItem
9068                 Item uint32
9069
9070                 //mt:if %s.Field == HUDDir
9071                 Dir uint32
9072
9073                 //mt:if %s.Field == HUDAlign
9074                 Align [2]float32
9075
9076                 //mt:if %s.Field == HUDOffset
9077                 Offset [2]float32
9078
9079                 //mt:if %s.Field == HUDWorldPos
9080                 WorldPos Pos
9081
9082                 //mt:if %s.Field == HUDSize
9083                 Size [2]int32
9084
9085                 //mt:if %s.Field == HUDZIndex
9086                 ZIndex int32
9087
9088                 //mt:if %s.Field == HUDText2
9089                 Text2 string
9090
9091                 //mt:if %s.Field == HUDStyle
9092                 Style HUDStyleFlags
9093         }))(obj)).Field == HUDText2 {
9094                 if len(([]byte((*(*(struct {
9095                         ID HUDID
9096
9097                         Field HUDField
9098
9099                         //mt:if %s.Field == HUDPos
9100                         Pos [2]float32
9101
9102                         //mt:if %s.Field == HUDName
9103                         Name string
9104
9105                         //mt:if %s.Field == HUDScale
9106                         Scale [2]float32
9107
9108                         //mt:if %s.Field == HUDText
9109                         Text string
9110
9111                         //mt:if %s.Field == HUDNumber
9112                         Number uint32
9113
9114                         //mt:if %s.Field == HUDItem
9115                         Item uint32
9116
9117                         //mt:if %s.Field == HUDDir
9118                         Dir uint32
9119
9120                         //mt:if %s.Field == HUDAlign
9121                         Align [2]float32
9122
9123                         //mt:if %s.Field == HUDOffset
9124                         Offset [2]float32
9125
9126                         //mt:if %s.Field == HUDWorldPos
9127                         WorldPos Pos
9128
9129                         //mt:if %s.Field == HUDSize
9130                         Size [2]int32
9131
9132                         //mt:if %s.Field == HUDZIndex
9133                         ZIndex int32
9134
9135                         //mt:if %s.Field == HUDText2
9136                         Text2 string
9137
9138                         //mt:if %s.Field == HUDStyle
9139                         Style HUDStyleFlags
9140                 }))(obj)).Text2))) > math.MaxUint16 {
9141                         chk(ErrTooLong)
9142                 }
9143                 {
9144                         x := uint16(len(([]byte((*(*(struct {
9145                                 ID HUDID
9146
9147                                 Field HUDField
9148
9149                                 //mt:if %s.Field == HUDPos
9150                                 Pos [2]float32
9151
9152                                 //mt:if %s.Field == HUDName
9153                                 Name string
9154
9155                                 //mt:if %s.Field == HUDScale
9156                                 Scale [2]float32
9157
9158                                 //mt:if %s.Field == HUDText
9159                                 Text string
9160
9161                                 //mt:if %s.Field == HUDNumber
9162                                 Number uint32
9163
9164                                 //mt:if %s.Field == HUDItem
9165                                 Item uint32
9166
9167                                 //mt:if %s.Field == HUDDir
9168                                 Dir uint32
9169
9170                                 //mt:if %s.Field == HUDAlign
9171                                 Align [2]float32
9172
9173                                 //mt:if %s.Field == HUDOffset
9174                                 Offset [2]float32
9175
9176                                 //mt:if %s.Field == HUDWorldPos
9177                                 WorldPos Pos
9178
9179                                 //mt:if %s.Field == HUDSize
9180                                 Size [2]int32
9181
9182                                 //mt:if %s.Field == HUDZIndex
9183                                 ZIndex int32
9184
9185                                 //mt:if %s.Field == HUDText2
9186                                 Text2 string
9187
9188                                 //mt:if %s.Field == HUDStyle
9189                                 Style HUDStyleFlags
9190                         }))(obj)).Text2))))
9191                         write16(w, uint16(x))
9192                 }
9193                 {
9194                         _, err := w.Write(([]byte((*(*(struct {
9195                                 ID HUDID
9196
9197                                 Field HUDField
9198
9199                                 //mt:if %s.Field == HUDPos
9200                                 Pos [2]float32
9201
9202                                 //mt:if %s.Field == HUDName
9203                                 Name string
9204
9205                                 //mt:if %s.Field == HUDScale
9206                                 Scale [2]float32
9207
9208                                 //mt:if %s.Field == HUDText
9209                                 Text string
9210
9211                                 //mt:if %s.Field == HUDNumber
9212                                 Number uint32
9213
9214                                 //mt:if %s.Field == HUDItem
9215                                 Item uint32
9216
9217                                 //mt:if %s.Field == HUDDir
9218                                 Dir uint32
9219
9220                                 //mt:if %s.Field == HUDAlign
9221                                 Align [2]float32
9222
9223                                 //mt:if %s.Field == HUDOffset
9224                                 Offset [2]float32
9225
9226                                 //mt:if %s.Field == HUDWorldPos
9227                                 WorldPos Pos
9228
9229                                 //mt:if %s.Field == HUDSize
9230                                 Size [2]int32
9231
9232                                 //mt:if %s.Field == HUDZIndex
9233                                 ZIndex int32
9234
9235                                 //mt:if %s.Field == HUDText2
9236                                 Text2 string
9237
9238                                 //mt:if %s.Field == HUDStyle
9239                                 Style HUDStyleFlags
9240                         }))(obj)).Text2))[:])
9241                         chk(err)
9242                 }
9243         }
9244         if (*(*(struct {
9245                 ID HUDID
9246
9247                 Field HUDField
9248
9249                 //mt:if %s.Field == HUDPos
9250                 Pos [2]float32
9251
9252                 //mt:if %s.Field == HUDName
9253                 Name string
9254
9255                 //mt:if %s.Field == HUDScale
9256                 Scale [2]float32
9257
9258                 //mt:if %s.Field == HUDText
9259                 Text string
9260
9261                 //mt:if %s.Field == HUDNumber
9262                 Number uint32
9263
9264                 //mt:if %s.Field == HUDItem
9265                 Item uint32
9266
9267                 //mt:if %s.Field == HUDDir
9268                 Dir uint32
9269
9270                 //mt:if %s.Field == HUDAlign
9271                 Align [2]float32
9272
9273                 //mt:if %s.Field == HUDOffset
9274                 Offset [2]float32
9275
9276                 //mt:if %s.Field == HUDWorldPos
9277                 WorldPos Pos
9278
9279                 //mt:if %s.Field == HUDSize
9280                 Size [2]int32
9281
9282                 //mt:if %s.Field == HUDZIndex
9283                 ZIndex int32
9284
9285                 //mt:if %s.Field == HUDText2
9286                 Text2 string
9287
9288                 //mt:if %s.Field == HUDStyle
9289                 Style HUDStyleFlags
9290         }))(obj)).Field == HUDStyle {
9291                 if err := pcall(func() {
9292                         ((*(*(struct {
9293                                 ID HUDID
9294
9295                                 Field HUDField
9296
9297                                 //mt:if %s.Field == HUDPos
9298                                 Pos [2]float32
9299
9300                                 //mt:if %s.Field == HUDName
9301                                 Name string
9302
9303                                 //mt:if %s.Field == HUDScale
9304                                 Scale [2]float32
9305
9306                                 //mt:if %s.Field == HUDText
9307                                 Text string
9308
9309                                 //mt:if %s.Field == HUDNumber
9310                                 Number uint32
9311
9312                                 //mt:if %s.Field == HUDItem
9313                                 Item uint32
9314
9315                                 //mt:if %s.Field == HUDDir
9316                                 Dir uint32
9317
9318                                 //mt:if %s.Field == HUDAlign
9319                                 Align [2]float32
9320
9321                                 //mt:if %s.Field == HUDOffset
9322                                 Offset [2]float32
9323
9324                                 //mt:if %s.Field == HUDWorldPos
9325                                 WorldPos Pos
9326
9327                                 //mt:if %s.Field == HUDSize
9328                                 Size [2]int32
9329
9330                                 //mt:if %s.Field == HUDZIndex
9331                                 ZIndex int32
9332
9333                                 //mt:if %s.Field == HUDText2
9334                                 Text2 string
9335
9336                                 //mt:if %s.Field == HUDStyle
9337                                 Style HUDStyleFlags
9338                         }))(obj)).Style).serialize(w)
9339                 }); err != nil {
9340                         if err == io.EOF {
9341                                 chk(io.EOF)
9342                         }
9343                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
9344                 }
9345         }
9346 }
9347
9348 func (obj *ToCltChangeHUD) deserialize(r io.Reader) {
9349         if err := pcall(func() {
9350                 ((*(*(struct {
9351                         ID HUDID
9352
9353                         Field HUDField
9354
9355                         //mt:if %s.Field == HUDPos
9356                         Pos [2]float32
9357
9358                         //mt:if %s.Field == HUDName
9359                         Name string
9360
9361                         //mt:if %s.Field == HUDScale
9362                         Scale [2]float32
9363
9364                         //mt:if %s.Field == HUDText
9365                         Text string
9366
9367                         //mt:if %s.Field == HUDNumber
9368                         Number uint32
9369
9370                         //mt:if %s.Field == HUDItem
9371                         Item uint32
9372
9373                         //mt:if %s.Field == HUDDir
9374                         Dir uint32
9375
9376                         //mt:if %s.Field == HUDAlign
9377                         Align [2]float32
9378
9379                         //mt:if %s.Field == HUDOffset
9380                         Offset [2]float32
9381
9382                         //mt:if %s.Field == HUDWorldPos
9383                         WorldPos Pos
9384
9385                         //mt:if %s.Field == HUDSize
9386                         Size [2]int32
9387
9388                         //mt:if %s.Field == HUDZIndex
9389                         ZIndex int32
9390
9391                         //mt:if %s.Field == HUDText2
9392                         Text2 string
9393
9394                         //mt:if %s.Field == HUDStyle
9395                         Style HUDStyleFlags
9396                 }))(obj)).ID).deserialize(r)
9397         }); err != nil {
9398                 if err == io.EOF {
9399                         chk(io.EOF)
9400                 }
9401                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDID", err))
9402         }
9403         if err := pcall(func() {
9404                 ((*(*(struct {
9405                         ID HUDID
9406
9407                         Field HUDField
9408
9409                         //mt:if %s.Field == HUDPos
9410                         Pos [2]float32
9411
9412                         //mt:if %s.Field == HUDName
9413                         Name string
9414
9415                         //mt:if %s.Field == HUDScale
9416                         Scale [2]float32
9417
9418                         //mt:if %s.Field == HUDText
9419                         Text string
9420
9421                         //mt:if %s.Field == HUDNumber
9422                         Number uint32
9423
9424                         //mt:if %s.Field == HUDItem
9425                         Item uint32
9426
9427                         //mt:if %s.Field == HUDDir
9428                         Dir uint32
9429
9430                         //mt:if %s.Field == HUDAlign
9431                         Align [2]float32
9432
9433                         //mt:if %s.Field == HUDOffset
9434                         Offset [2]float32
9435
9436                         //mt:if %s.Field == HUDWorldPos
9437                         WorldPos Pos
9438
9439                         //mt:if %s.Field == HUDSize
9440                         Size [2]int32
9441
9442                         //mt:if %s.Field == HUDZIndex
9443                         ZIndex int32
9444
9445                         //mt:if %s.Field == HUDText2
9446                         Text2 string
9447
9448                         //mt:if %s.Field == HUDStyle
9449                         Style HUDStyleFlags
9450                 }))(obj)).Field).deserialize(r)
9451         }); err != nil {
9452                 if err == io.EOF {
9453                         chk(io.EOF)
9454                 }
9455                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDField", err))
9456         }
9457         if !((*(*(struct {
9458                 ID HUDID
9459
9460                 Field HUDField
9461
9462                 //mt:if %s.Field == HUDPos
9463                 Pos [2]float32
9464
9465                 //mt:if %s.Field == HUDName
9466                 Name string
9467
9468                 //mt:if %s.Field == HUDScale
9469                 Scale [2]float32
9470
9471                 //mt:if %s.Field == HUDText
9472                 Text string
9473
9474                 //mt:if %s.Field == HUDNumber
9475                 Number uint32
9476
9477                 //mt:if %s.Field == HUDItem
9478                 Item uint32
9479
9480                 //mt:if %s.Field == HUDDir
9481                 Dir uint32
9482
9483                 //mt:if %s.Field == HUDAlign
9484                 Align [2]float32
9485
9486                 //mt:if %s.Field == HUDOffset
9487                 Offset [2]float32
9488
9489                 //mt:if %s.Field == HUDWorldPos
9490                 WorldPos Pos
9491
9492                 //mt:if %s.Field == HUDSize
9493                 Size [2]int32
9494
9495                 //mt:if %s.Field == HUDZIndex
9496                 ZIndex int32
9497
9498                 //mt:if %s.Field == HUDText2
9499                 Text2 string
9500
9501                 //mt:if %s.Field == HUDStyle
9502                 Style HUDStyleFlags
9503         }))(obj)).Field < hudMax) {
9504                 chk(errors.New("assertion failed: %s.Field < hudMax"))
9505         }
9506         if (*(*(struct {
9507                 ID HUDID
9508
9509                 Field HUDField
9510
9511                 //mt:if %s.Field == HUDPos
9512                 Pos [2]float32
9513
9514                 //mt:if %s.Field == HUDName
9515                 Name string
9516
9517                 //mt:if %s.Field == HUDScale
9518                 Scale [2]float32
9519
9520                 //mt:if %s.Field == HUDText
9521                 Text string
9522
9523                 //mt:if %s.Field == HUDNumber
9524                 Number uint32
9525
9526                 //mt:if %s.Field == HUDItem
9527                 Item uint32
9528
9529                 //mt:if %s.Field == HUDDir
9530                 Dir uint32
9531
9532                 //mt:if %s.Field == HUDAlign
9533                 Align [2]float32
9534
9535                 //mt:if %s.Field == HUDOffset
9536                 Offset [2]float32
9537
9538                 //mt:if %s.Field == HUDWorldPos
9539                 WorldPos Pos
9540
9541                 //mt:if %s.Field == HUDSize
9542                 Size [2]int32
9543
9544                 //mt:if %s.Field == HUDZIndex
9545                 ZIndex int32
9546
9547                 //mt:if %s.Field == HUDText2
9548                 Text2 string
9549
9550                 //mt:if %s.Field == HUDStyle
9551                 Style HUDStyleFlags
9552         }))(obj)).Field == HUDPos {
9553                 for local177 := range (*(*(struct {
9554                         ID HUDID
9555
9556                         Field HUDField
9557
9558                         //mt:if %s.Field == HUDPos
9559                         Pos [2]float32
9560
9561                         //mt:if %s.Field == HUDName
9562                         Name string
9563
9564                         //mt:if %s.Field == HUDScale
9565                         Scale [2]float32
9566
9567                         //mt:if %s.Field == HUDText
9568                         Text string
9569
9570                         //mt:if %s.Field == HUDNumber
9571                         Number uint32
9572
9573                         //mt:if %s.Field == HUDItem
9574                         Item uint32
9575
9576                         //mt:if %s.Field == HUDDir
9577                         Dir uint32
9578
9579                         //mt:if %s.Field == HUDAlign
9580                         Align [2]float32
9581
9582                         //mt:if %s.Field == HUDOffset
9583                         Offset [2]float32
9584
9585                         //mt:if %s.Field == HUDWorldPos
9586                         WorldPos Pos
9587
9588                         //mt:if %s.Field == HUDSize
9589                         Size [2]int32
9590
9591                         //mt:if %s.Field == HUDZIndex
9592                         ZIndex int32
9593
9594                         //mt:if %s.Field == HUDText2
9595                         Text2 string
9596
9597                         //mt:if %s.Field == HUDStyle
9598                         Style HUDStyleFlags
9599                 }))(obj)).Pos {
9600                         {
9601                                 p := &((*(*(struct {
9602                                         ID HUDID
9603
9604                                         Field HUDField
9605
9606                                         //mt:if %s.Field == HUDPos
9607                                         Pos [2]float32
9608
9609                                         //mt:if %s.Field == HUDName
9610                                         Name string
9611
9612                                         //mt:if %s.Field == HUDScale
9613                                         Scale [2]float32
9614
9615                                         //mt:if %s.Field == HUDText
9616                                         Text string
9617
9618                                         //mt:if %s.Field == HUDNumber
9619                                         Number uint32
9620
9621                                         //mt:if %s.Field == HUDItem
9622                                         Item uint32
9623
9624                                         //mt:if %s.Field == HUDDir
9625                                         Dir uint32
9626
9627                                         //mt:if %s.Field == HUDAlign
9628                                         Align [2]float32
9629
9630                                         //mt:if %s.Field == HUDOffset
9631                                         Offset [2]float32
9632
9633                                         //mt:if %s.Field == HUDWorldPos
9634                                         WorldPos Pos
9635
9636                                         //mt:if %s.Field == HUDSize
9637                                         Size [2]int32
9638
9639                                         //mt:if %s.Field == HUDZIndex
9640                                         ZIndex int32
9641
9642                                         //mt:if %s.Field == HUDText2
9643                                         Text2 string
9644
9645                                         //mt:if %s.Field == HUDStyle
9646                                         Style HUDStyleFlags
9647                                 }))(obj)).Pos)[local177]
9648                                 *p = math.Float32frombits(read32(r))
9649                         }
9650                 }
9651         }
9652         if (*(*(struct {
9653                 ID HUDID
9654
9655                 Field HUDField
9656
9657                 //mt:if %s.Field == HUDPos
9658                 Pos [2]float32
9659
9660                 //mt:if %s.Field == HUDName
9661                 Name string
9662
9663                 //mt:if %s.Field == HUDScale
9664                 Scale [2]float32
9665
9666                 //mt:if %s.Field == HUDText
9667                 Text string
9668
9669                 //mt:if %s.Field == HUDNumber
9670                 Number uint32
9671
9672                 //mt:if %s.Field == HUDItem
9673                 Item uint32
9674
9675                 //mt:if %s.Field == HUDDir
9676                 Dir uint32
9677
9678                 //mt:if %s.Field == HUDAlign
9679                 Align [2]float32
9680
9681                 //mt:if %s.Field == HUDOffset
9682                 Offset [2]float32
9683
9684                 //mt:if %s.Field == HUDWorldPos
9685                 WorldPos Pos
9686
9687                 //mt:if %s.Field == HUDSize
9688                 Size [2]int32
9689
9690                 //mt:if %s.Field == HUDZIndex
9691                 ZIndex int32
9692
9693                 //mt:if %s.Field == HUDText2
9694                 Text2 string
9695
9696                 //mt:if %s.Field == HUDStyle
9697                 Style HUDStyleFlags
9698         }))(obj)).Field == HUDName {
9699                 var local178 []uint8
9700                 var local179 uint16
9701                 {
9702                         p := &local179
9703                         *p = read16(r)
9704                 }
9705                 (local178) = make([]uint8, local179)
9706                 {
9707                         _, err := io.ReadFull(r, (local178)[:])
9708                         chk(err)
9709                 }
9710                 ((*(*(struct {
9711                         ID HUDID
9712
9713                         Field HUDField
9714
9715                         //mt:if %s.Field == HUDPos
9716                         Pos [2]float32
9717
9718                         //mt:if %s.Field == HUDName
9719                         Name string
9720
9721                         //mt:if %s.Field == HUDScale
9722                         Scale [2]float32
9723
9724                         //mt:if %s.Field == HUDText
9725                         Text string
9726
9727                         //mt:if %s.Field == HUDNumber
9728                         Number uint32
9729
9730                         //mt:if %s.Field == HUDItem
9731                         Item uint32
9732
9733                         //mt:if %s.Field == HUDDir
9734                         Dir uint32
9735
9736                         //mt:if %s.Field == HUDAlign
9737                         Align [2]float32
9738
9739                         //mt:if %s.Field == HUDOffset
9740                         Offset [2]float32
9741
9742                         //mt:if %s.Field == HUDWorldPos
9743                         WorldPos Pos
9744
9745                         //mt:if %s.Field == HUDSize
9746                         Size [2]int32
9747
9748                         //mt:if %s.Field == HUDZIndex
9749                         ZIndex int32
9750
9751                         //mt:if %s.Field == HUDText2
9752                         Text2 string
9753
9754                         //mt:if %s.Field == HUDStyle
9755                         Style HUDStyleFlags
9756                 }))(obj)).Name) = string(local178)
9757         }
9758         if (*(*(struct {
9759                 ID HUDID
9760
9761                 Field HUDField
9762
9763                 //mt:if %s.Field == HUDPos
9764                 Pos [2]float32
9765
9766                 //mt:if %s.Field == HUDName
9767                 Name string
9768
9769                 //mt:if %s.Field == HUDScale
9770                 Scale [2]float32
9771
9772                 //mt:if %s.Field == HUDText
9773                 Text string
9774
9775                 //mt:if %s.Field == HUDNumber
9776                 Number uint32
9777
9778                 //mt:if %s.Field == HUDItem
9779                 Item uint32
9780
9781                 //mt:if %s.Field == HUDDir
9782                 Dir uint32
9783
9784                 //mt:if %s.Field == HUDAlign
9785                 Align [2]float32
9786
9787                 //mt:if %s.Field == HUDOffset
9788                 Offset [2]float32
9789
9790                 //mt:if %s.Field == HUDWorldPos
9791                 WorldPos Pos
9792
9793                 //mt:if %s.Field == HUDSize
9794                 Size [2]int32
9795
9796                 //mt:if %s.Field == HUDZIndex
9797                 ZIndex int32
9798
9799                 //mt:if %s.Field == HUDText2
9800                 Text2 string
9801
9802                 //mt:if %s.Field == HUDStyle
9803                 Style HUDStyleFlags
9804         }))(obj)).Field == HUDScale {
9805                 for local180 := range (*(*(struct {
9806                         ID HUDID
9807
9808                         Field HUDField
9809
9810                         //mt:if %s.Field == HUDPos
9811                         Pos [2]float32
9812
9813                         //mt:if %s.Field == HUDName
9814                         Name string
9815
9816                         //mt:if %s.Field == HUDScale
9817                         Scale [2]float32
9818
9819                         //mt:if %s.Field == HUDText
9820                         Text string
9821
9822                         //mt:if %s.Field == HUDNumber
9823                         Number uint32
9824
9825                         //mt:if %s.Field == HUDItem
9826                         Item uint32
9827
9828                         //mt:if %s.Field == HUDDir
9829                         Dir uint32
9830
9831                         //mt:if %s.Field == HUDAlign
9832                         Align [2]float32
9833
9834                         //mt:if %s.Field == HUDOffset
9835                         Offset [2]float32
9836
9837                         //mt:if %s.Field == HUDWorldPos
9838                         WorldPos Pos
9839
9840                         //mt:if %s.Field == HUDSize
9841                         Size [2]int32
9842
9843                         //mt:if %s.Field == HUDZIndex
9844                         ZIndex int32
9845
9846                         //mt:if %s.Field == HUDText2
9847                         Text2 string
9848
9849                         //mt:if %s.Field == HUDStyle
9850                         Style HUDStyleFlags
9851                 }))(obj)).Scale {
9852                         {
9853                                 p := &((*(*(struct {
9854                                         ID HUDID
9855
9856                                         Field HUDField
9857
9858                                         //mt:if %s.Field == HUDPos
9859                                         Pos [2]float32
9860
9861                                         //mt:if %s.Field == HUDName
9862                                         Name string
9863
9864                                         //mt:if %s.Field == HUDScale
9865                                         Scale [2]float32
9866
9867                                         //mt:if %s.Field == HUDText
9868                                         Text string
9869
9870                                         //mt:if %s.Field == HUDNumber
9871                                         Number uint32
9872
9873                                         //mt:if %s.Field == HUDItem
9874                                         Item uint32
9875
9876                                         //mt:if %s.Field == HUDDir
9877                                         Dir uint32
9878
9879                                         //mt:if %s.Field == HUDAlign
9880                                         Align [2]float32
9881
9882                                         //mt:if %s.Field == HUDOffset
9883                                         Offset [2]float32
9884
9885                                         //mt:if %s.Field == HUDWorldPos
9886                                         WorldPos Pos
9887
9888                                         //mt:if %s.Field == HUDSize
9889                                         Size [2]int32
9890
9891                                         //mt:if %s.Field == HUDZIndex
9892                                         ZIndex int32
9893
9894                                         //mt:if %s.Field == HUDText2
9895                                         Text2 string
9896
9897                                         //mt:if %s.Field == HUDStyle
9898                                         Style HUDStyleFlags
9899                                 }))(obj)).Scale)[local180]
9900                                 *p = math.Float32frombits(read32(r))
9901                         }
9902                 }
9903         }
9904         if (*(*(struct {
9905                 ID HUDID
9906
9907                 Field HUDField
9908
9909                 //mt:if %s.Field == HUDPos
9910                 Pos [2]float32
9911
9912                 //mt:if %s.Field == HUDName
9913                 Name string
9914
9915                 //mt:if %s.Field == HUDScale
9916                 Scale [2]float32
9917
9918                 //mt:if %s.Field == HUDText
9919                 Text string
9920
9921                 //mt:if %s.Field == HUDNumber
9922                 Number uint32
9923
9924                 //mt:if %s.Field == HUDItem
9925                 Item uint32
9926
9927                 //mt:if %s.Field == HUDDir
9928                 Dir uint32
9929
9930                 //mt:if %s.Field == HUDAlign
9931                 Align [2]float32
9932
9933                 //mt:if %s.Field == HUDOffset
9934                 Offset [2]float32
9935
9936                 //mt:if %s.Field == HUDWorldPos
9937                 WorldPos Pos
9938
9939                 //mt:if %s.Field == HUDSize
9940                 Size [2]int32
9941
9942                 //mt:if %s.Field == HUDZIndex
9943                 ZIndex int32
9944
9945                 //mt:if %s.Field == HUDText2
9946                 Text2 string
9947
9948                 //mt:if %s.Field == HUDStyle
9949                 Style HUDStyleFlags
9950         }))(obj)).Field == HUDText {
9951                 var local181 []uint8
9952                 var local182 uint16
9953                 {
9954                         p := &local182
9955                         *p = read16(r)
9956                 }
9957                 (local181) = make([]uint8, local182)
9958                 {
9959                         _, err := io.ReadFull(r, (local181)[:])
9960                         chk(err)
9961                 }
9962                 ((*(*(struct {
9963                         ID HUDID
9964
9965                         Field HUDField
9966
9967                         //mt:if %s.Field == HUDPos
9968                         Pos [2]float32
9969
9970                         //mt:if %s.Field == HUDName
9971                         Name string
9972
9973                         //mt:if %s.Field == HUDScale
9974                         Scale [2]float32
9975
9976                         //mt:if %s.Field == HUDText
9977                         Text string
9978
9979                         //mt:if %s.Field == HUDNumber
9980                         Number uint32
9981
9982                         //mt:if %s.Field == HUDItem
9983                         Item uint32
9984
9985                         //mt:if %s.Field == HUDDir
9986                         Dir uint32
9987
9988                         //mt:if %s.Field == HUDAlign
9989                         Align [2]float32
9990
9991                         //mt:if %s.Field == HUDOffset
9992                         Offset [2]float32
9993
9994                         //mt:if %s.Field == HUDWorldPos
9995                         WorldPos Pos
9996
9997                         //mt:if %s.Field == HUDSize
9998                         Size [2]int32
9999
10000                         //mt:if %s.Field == HUDZIndex
10001                         ZIndex int32
10002
10003                         //mt:if %s.Field == HUDText2
10004                         Text2 string
10005
10006                         //mt:if %s.Field == HUDStyle
10007                         Style HUDStyleFlags
10008                 }))(obj)).Text) = string(local181)
10009         }
10010         if (*(*(struct {
10011                 ID HUDID
10012
10013                 Field HUDField
10014
10015                 //mt:if %s.Field == HUDPos
10016                 Pos [2]float32
10017
10018                 //mt:if %s.Field == HUDName
10019                 Name string
10020
10021                 //mt:if %s.Field == HUDScale
10022                 Scale [2]float32
10023
10024                 //mt:if %s.Field == HUDText
10025                 Text string
10026
10027                 //mt:if %s.Field == HUDNumber
10028                 Number uint32
10029
10030                 //mt:if %s.Field == HUDItem
10031                 Item uint32
10032
10033                 //mt:if %s.Field == HUDDir
10034                 Dir uint32
10035
10036                 //mt:if %s.Field == HUDAlign
10037                 Align [2]float32
10038
10039                 //mt:if %s.Field == HUDOffset
10040                 Offset [2]float32
10041
10042                 //mt:if %s.Field == HUDWorldPos
10043                 WorldPos Pos
10044
10045                 //mt:if %s.Field == HUDSize
10046                 Size [2]int32
10047
10048                 //mt:if %s.Field == HUDZIndex
10049                 ZIndex int32
10050
10051                 //mt:if %s.Field == HUDText2
10052                 Text2 string
10053
10054                 //mt:if %s.Field == HUDStyle
10055                 Style HUDStyleFlags
10056         }))(obj)).Field == HUDNumber {
10057                 {
10058                         p := &(*(*(struct {
10059                                 ID HUDID
10060
10061                                 Field HUDField
10062
10063                                 //mt:if %s.Field == HUDPos
10064                                 Pos [2]float32
10065
10066                                 //mt:if %s.Field == HUDName
10067                                 Name string
10068
10069                                 //mt:if %s.Field == HUDScale
10070                                 Scale [2]float32
10071
10072                                 //mt:if %s.Field == HUDText
10073                                 Text string
10074
10075                                 //mt:if %s.Field == HUDNumber
10076                                 Number uint32
10077
10078                                 //mt:if %s.Field == HUDItem
10079                                 Item uint32
10080
10081                                 //mt:if %s.Field == HUDDir
10082                                 Dir uint32
10083
10084                                 //mt:if %s.Field == HUDAlign
10085                                 Align [2]float32
10086
10087                                 //mt:if %s.Field == HUDOffset
10088                                 Offset [2]float32
10089
10090                                 //mt:if %s.Field == HUDWorldPos
10091                                 WorldPos Pos
10092
10093                                 //mt:if %s.Field == HUDSize
10094                                 Size [2]int32
10095
10096                                 //mt:if %s.Field == HUDZIndex
10097                                 ZIndex int32
10098
10099                                 //mt:if %s.Field == HUDText2
10100                                 Text2 string
10101
10102                                 //mt:if %s.Field == HUDStyle
10103                                 Style HUDStyleFlags
10104                         }))(obj)).Number
10105                         *p = read32(r)
10106                 }
10107         }
10108         if (*(*(struct {
10109                 ID HUDID
10110
10111                 Field HUDField
10112
10113                 //mt:if %s.Field == HUDPos
10114                 Pos [2]float32
10115
10116                 //mt:if %s.Field == HUDName
10117                 Name string
10118
10119                 //mt:if %s.Field == HUDScale
10120                 Scale [2]float32
10121
10122                 //mt:if %s.Field == HUDText
10123                 Text string
10124
10125                 //mt:if %s.Field == HUDNumber
10126                 Number uint32
10127
10128                 //mt:if %s.Field == HUDItem
10129                 Item uint32
10130
10131                 //mt:if %s.Field == HUDDir
10132                 Dir uint32
10133
10134                 //mt:if %s.Field == HUDAlign
10135                 Align [2]float32
10136
10137                 //mt:if %s.Field == HUDOffset
10138                 Offset [2]float32
10139
10140                 //mt:if %s.Field == HUDWorldPos
10141                 WorldPos Pos
10142
10143                 //mt:if %s.Field == HUDSize
10144                 Size [2]int32
10145
10146                 //mt:if %s.Field == HUDZIndex
10147                 ZIndex int32
10148
10149                 //mt:if %s.Field == HUDText2
10150                 Text2 string
10151
10152                 //mt:if %s.Field == HUDStyle
10153                 Style HUDStyleFlags
10154         }))(obj)).Field == HUDItem {
10155                 {
10156                         p := &(*(*(struct {
10157                                 ID HUDID
10158
10159                                 Field HUDField
10160
10161                                 //mt:if %s.Field == HUDPos
10162                                 Pos [2]float32
10163
10164                                 //mt:if %s.Field == HUDName
10165                                 Name string
10166
10167                                 //mt:if %s.Field == HUDScale
10168                                 Scale [2]float32
10169
10170                                 //mt:if %s.Field == HUDText
10171                                 Text string
10172
10173                                 //mt:if %s.Field == HUDNumber
10174                                 Number uint32
10175
10176                                 //mt:if %s.Field == HUDItem
10177                                 Item uint32
10178
10179                                 //mt:if %s.Field == HUDDir
10180                                 Dir uint32
10181
10182                                 //mt:if %s.Field == HUDAlign
10183                                 Align [2]float32
10184
10185                                 //mt:if %s.Field == HUDOffset
10186                                 Offset [2]float32
10187
10188                                 //mt:if %s.Field == HUDWorldPos
10189                                 WorldPos Pos
10190
10191                                 //mt:if %s.Field == HUDSize
10192                                 Size [2]int32
10193
10194                                 //mt:if %s.Field == HUDZIndex
10195                                 ZIndex int32
10196
10197                                 //mt:if %s.Field == HUDText2
10198                                 Text2 string
10199
10200                                 //mt:if %s.Field == HUDStyle
10201                                 Style HUDStyleFlags
10202                         }))(obj)).Item
10203                         *p = read32(r)
10204                 }
10205         }
10206         if (*(*(struct {
10207                 ID HUDID
10208
10209                 Field HUDField
10210
10211                 //mt:if %s.Field == HUDPos
10212                 Pos [2]float32
10213
10214                 //mt:if %s.Field == HUDName
10215                 Name string
10216
10217                 //mt:if %s.Field == HUDScale
10218                 Scale [2]float32
10219
10220                 //mt:if %s.Field == HUDText
10221                 Text string
10222
10223                 //mt:if %s.Field == HUDNumber
10224                 Number uint32
10225
10226                 //mt:if %s.Field == HUDItem
10227                 Item uint32
10228
10229                 //mt:if %s.Field == HUDDir
10230                 Dir uint32
10231
10232                 //mt:if %s.Field == HUDAlign
10233                 Align [2]float32
10234
10235                 //mt:if %s.Field == HUDOffset
10236                 Offset [2]float32
10237
10238                 //mt:if %s.Field == HUDWorldPos
10239                 WorldPos Pos
10240
10241                 //mt:if %s.Field == HUDSize
10242                 Size [2]int32
10243
10244                 //mt:if %s.Field == HUDZIndex
10245                 ZIndex int32
10246
10247                 //mt:if %s.Field == HUDText2
10248                 Text2 string
10249
10250                 //mt:if %s.Field == HUDStyle
10251                 Style HUDStyleFlags
10252         }))(obj)).Field == HUDDir {
10253                 {
10254                         p := &(*(*(struct {
10255                                 ID HUDID
10256
10257                                 Field HUDField
10258
10259                                 //mt:if %s.Field == HUDPos
10260                                 Pos [2]float32
10261
10262                                 //mt:if %s.Field == HUDName
10263                                 Name string
10264
10265                                 //mt:if %s.Field == HUDScale
10266                                 Scale [2]float32
10267
10268                                 //mt:if %s.Field == HUDText
10269                                 Text string
10270
10271                                 //mt:if %s.Field == HUDNumber
10272                                 Number uint32
10273
10274                                 //mt:if %s.Field == HUDItem
10275                                 Item uint32
10276
10277                                 //mt:if %s.Field == HUDDir
10278                                 Dir uint32
10279
10280                                 //mt:if %s.Field == HUDAlign
10281                                 Align [2]float32
10282
10283                                 //mt:if %s.Field == HUDOffset
10284                                 Offset [2]float32
10285
10286                                 //mt:if %s.Field == HUDWorldPos
10287                                 WorldPos Pos
10288
10289                                 //mt:if %s.Field == HUDSize
10290                                 Size [2]int32
10291
10292                                 //mt:if %s.Field == HUDZIndex
10293                                 ZIndex int32
10294
10295                                 //mt:if %s.Field == HUDText2
10296                                 Text2 string
10297
10298                                 //mt:if %s.Field == HUDStyle
10299                                 Style HUDStyleFlags
10300                         }))(obj)).Dir
10301                         *p = read32(r)
10302                 }
10303         }
10304         if (*(*(struct {
10305                 ID HUDID
10306
10307                 Field HUDField
10308
10309                 //mt:if %s.Field == HUDPos
10310                 Pos [2]float32
10311
10312                 //mt:if %s.Field == HUDName
10313                 Name string
10314
10315                 //mt:if %s.Field == HUDScale
10316                 Scale [2]float32
10317
10318                 //mt:if %s.Field == HUDText
10319                 Text string
10320
10321                 //mt:if %s.Field == HUDNumber
10322                 Number uint32
10323
10324                 //mt:if %s.Field == HUDItem
10325                 Item uint32
10326
10327                 //mt:if %s.Field == HUDDir
10328                 Dir uint32
10329
10330                 //mt:if %s.Field == HUDAlign
10331                 Align [2]float32
10332
10333                 //mt:if %s.Field == HUDOffset
10334                 Offset [2]float32
10335
10336                 //mt:if %s.Field == HUDWorldPos
10337                 WorldPos Pos
10338
10339                 //mt:if %s.Field == HUDSize
10340                 Size [2]int32
10341
10342                 //mt:if %s.Field == HUDZIndex
10343                 ZIndex int32
10344
10345                 //mt:if %s.Field == HUDText2
10346                 Text2 string
10347
10348                 //mt:if %s.Field == HUDStyle
10349                 Style HUDStyleFlags
10350         }))(obj)).Field == HUDAlign {
10351                 for local183 := range (*(*(struct {
10352                         ID HUDID
10353
10354                         Field HUDField
10355
10356                         //mt:if %s.Field == HUDPos
10357                         Pos [2]float32
10358
10359                         //mt:if %s.Field == HUDName
10360                         Name string
10361
10362                         //mt:if %s.Field == HUDScale
10363                         Scale [2]float32
10364
10365                         //mt:if %s.Field == HUDText
10366                         Text string
10367
10368                         //mt:if %s.Field == HUDNumber
10369                         Number uint32
10370
10371                         //mt:if %s.Field == HUDItem
10372                         Item uint32
10373
10374                         //mt:if %s.Field == HUDDir
10375                         Dir uint32
10376
10377                         //mt:if %s.Field == HUDAlign
10378                         Align [2]float32
10379
10380                         //mt:if %s.Field == HUDOffset
10381                         Offset [2]float32
10382
10383                         //mt:if %s.Field == HUDWorldPos
10384                         WorldPos Pos
10385
10386                         //mt:if %s.Field == HUDSize
10387                         Size [2]int32
10388
10389                         //mt:if %s.Field == HUDZIndex
10390                         ZIndex int32
10391
10392                         //mt:if %s.Field == HUDText2
10393                         Text2 string
10394
10395                         //mt:if %s.Field == HUDStyle
10396                         Style HUDStyleFlags
10397                 }))(obj)).Align {
10398                         {
10399                                 p := &((*(*(struct {
10400                                         ID HUDID
10401
10402                                         Field HUDField
10403
10404                                         //mt:if %s.Field == HUDPos
10405                                         Pos [2]float32
10406
10407                                         //mt:if %s.Field == HUDName
10408                                         Name string
10409
10410                                         //mt:if %s.Field == HUDScale
10411                                         Scale [2]float32
10412
10413                                         //mt:if %s.Field == HUDText
10414                                         Text string
10415
10416                                         //mt:if %s.Field == HUDNumber
10417                                         Number uint32
10418
10419                                         //mt:if %s.Field == HUDItem
10420                                         Item uint32
10421
10422                                         //mt:if %s.Field == HUDDir
10423                                         Dir uint32
10424
10425                                         //mt:if %s.Field == HUDAlign
10426                                         Align [2]float32
10427
10428                                         //mt:if %s.Field == HUDOffset
10429                                         Offset [2]float32
10430
10431                                         //mt:if %s.Field == HUDWorldPos
10432                                         WorldPos Pos
10433
10434                                         //mt:if %s.Field == HUDSize
10435                                         Size [2]int32
10436
10437                                         //mt:if %s.Field == HUDZIndex
10438                                         ZIndex int32
10439
10440                                         //mt:if %s.Field == HUDText2
10441                                         Text2 string
10442
10443                                         //mt:if %s.Field == HUDStyle
10444                                         Style HUDStyleFlags
10445                                 }))(obj)).Align)[local183]
10446                                 *p = math.Float32frombits(read32(r))
10447                         }
10448                 }
10449         }
10450         if (*(*(struct {
10451                 ID HUDID
10452
10453                 Field HUDField
10454
10455                 //mt:if %s.Field == HUDPos
10456                 Pos [2]float32
10457
10458                 //mt:if %s.Field == HUDName
10459                 Name string
10460
10461                 //mt:if %s.Field == HUDScale
10462                 Scale [2]float32
10463
10464                 //mt:if %s.Field == HUDText
10465                 Text string
10466
10467                 //mt:if %s.Field == HUDNumber
10468                 Number uint32
10469
10470                 //mt:if %s.Field == HUDItem
10471                 Item uint32
10472
10473                 //mt:if %s.Field == HUDDir
10474                 Dir uint32
10475
10476                 //mt:if %s.Field == HUDAlign
10477                 Align [2]float32
10478
10479                 //mt:if %s.Field == HUDOffset
10480                 Offset [2]float32
10481
10482                 //mt:if %s.Field == HUDWorldPos
10483                 WorldPos Pos
10484
10485                 //mt:if %s.Field == HUDSize
10486                 Size [2]int32
10487
10488                 //mt:if %s.Field == HUDZIndex
10489                 ZIndex int32
10490
10491                 //mt:if %s.Field == HUDText2
10492                 Text2 string
10493
10494                 //mt:if %s.Field == HUDStyle
10495                 Style HUDStyleFlags
10496         }))(obj)).Field == HUDOffset {
10497                 for local184 := range (*(*(struct {
10498                         ID HUDID
10499
10500                         Field HUDField
10501
10502                         //mt:if %s.Field == HUDPos
10503                         Pos [2]float32
10504
10505                         //mt:if %s.Field == HUDName
10506                         Name string
10507
10508                         //mt:if %s.Field == HUDScale
10509                         Scale [2]float32
10510
10511                         //mt:if %s.Field == HUDText
10512                         Text string
10513
10514                         //mt:if %s.Field == HUDNumber
10515                         Number uint32
10516
10517                         //mt:if %s.Field == HUDItem
10518                         Item uint32
10519
10520                         //mt:if %s.Field == HUDDir
10521                         Dir uint32
10522
10523                         //mt:if %s.Field == HUDAlign
10524                         Align [2]float32
10525
10526                         //mt:if %s.Field == HUDOffset
10527                         Offset [2]float32
10528
10529                         //mt:if %s.Field == HUDWorldPos
10530                         WorldPos Pos
10531
10532                         //mt:if %s.Field == HUDSize
10533                         Size [2]int32
10534
10535                         //mt:if %s.Field == HUDZIndex
10536                         ZIndex int32
10537
10538                         //mt:if %s.Field == HUDText2
10539                         Text2 string
10540
10541                         //mt:if %s.Field == HUDStyle
10542                         Style HUDStyleFlags
10543                 }))(obj)).Offset {
10544                         {
10545                                 p := &((*(*(struct {
10546                                         ID HUDID
10547
10548                                         Field HUDField
10549
10550                                         //mt:if %s.Field == HUDPos
10551                                         Pos [2]float32
10552
10553                                         //mt:if %s.Field == HUDName
10554                                         Name string
10555
10556                                         //mt:if %s.Field == HUDScale
10557                                         Scale [2]float32
10558
10559                                         //mt:if %s.Field == HUDText
10560                                         Text string
10561
10562                                         //mt:if %s.Field == HUDNumber
10563                                         Number uint32
10564
10565                                         //mt:if %s.Field == HUDItem
10566                                         Item uint32
10567
10568                                         //mt:if %s.Field == HUDDir
10569                                         Dir uint32
10570
10571                                         //mt:if %s.Field == HUDAlign
10572                                         Align [2]float32
10573
10574                                         //mt:if %s.Field == HUDOffset
10575                                         Offset [2]float32
10576
10577                                         //mt:if %s.Field == HUDWorldPos
10578                                         WorldPos Pos
10579
10580                                         //mt:if %s.Field == HUDSize
10581                                         Size [2]int32
10582
10583                                         //mt:if %s.Field == HUDZIndex
10584                                         ZIndex int32
10585
10586                                         //mt:if %s.Field == HUDText2
10587                                         Text2 string
10588
10589                                         //mt:if %s.Field == HUDStyle
10590                                         Style HUDStyleFlags
10591                                 }))(obj)).Offset)[local184]
10592                                 *p = math.Float32frombits(read32(r))
10593                         }
10594                 }
10595         }
10596         if (*(*(struct {
10597                 ID HUDID
10598
10599                 Field HUDField
10600
10601                 //mt:if %s.Field == HUDPos
10602                 Pos [2]float32
10603
10604                 //mt:if %s.Field == HUDName
10605                 Name string
10606
10607                 //mt:if %s.Field == HUDScale
10608                 Scale [2]float32
10609
10610                 //mt:if %s.Field == HUDText
10611                 Text string
10612
10613                 //mt:if %s.Field == HUDNumber
10614                 Number uint32
10615
10616                 //mt:if %s.Field == HUDItem
10617                 Item uint32
10618
10619                 //mt:if %s.Field == HUDDir
10620                 Dir uint32
10621
10622                 //mt:if %s.Field == HUDAlign
10623                 Align [2]float32
10624
10625                 //mt:if %s.Field == HUDOffset
10626                 Offset [2]float32
10627
10628                 //mt:if %s.Field == HUDWorldPos
10629                 WorldPos Pos
10630
10631                 //mt:if %s.Field == HUDSize
10632                 Size [2]int32
10633
10634                 //mt:if %s.Field == HUDZIndex
10635                 ZIndex int32
10636
10637                 //mt:if %s.Field == HUDText2
10638                 Text2 string
10639
10640                 //mt:if %s.Field == HUDStyle
10641                 Style HUDStyleFlags
10642         }))(obj)).Field == HUDWorldPos {
10643                 if err := pcall(func() {
10644                         ((*(*(struct {
10645                                 ID HUDID
10646
10647                                 Field HUDField
10648
10649                                 //mt:if %s.Field == HUDPos
10650                                 Pos [2]float32
10651
10652                                 //mt:if %s.Field == HUDName
10653                                 Name string
10654
10655                                 //mt:if %s.Field == HUDScale
10656                                 Scale [2]float32
10657
10658                                 //mt:if %s.Field == HUDText
10659                                 Text string
10660
10661                                 //mt:if %s.Field == HUDNumber
10662                                 Number uint32
10663
10664                                 //mt:if %s.Field == HUDItem
10665                                 Item uint32
10666
10667                                 //mt:if %s.Field == HUDDir
10668                                 Dir uint32
10669
10670                                 //mt:if %s.Field == HUDAlign
10671                                 Align [2]float32
10672
10673                                 //mt:if %s.Field == HUDOffset
10674                                 Offset [2]float32
10675
10676                                 //mt:if %s.Field == HUDWorldPos
10677                                 WorldPos Pos
10678
10679                                 //mt:if %s.Field == HUDSize
10680                                 Size [2]int32
10681
10682                                 //mt:if %s.Field == HUDZIndex
10683                                 ZIndex int32
10684
10685                                 //mt:if %s.Field == HUDText2
10686                                 Text2 string
10687
10688                                 //mt:if %s.Field == HUDStyle
10689                                 Style HUDStyleFlags
10690                         }))(obj)).WorldPos).deserialize(r)
10691                 }); err != nil {
10692                         if err == io.EOF {
10693                                 chk(io.EOF)
10694                         }
10695                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
10696                 }
10697         }
10698         if (*(*(struct {
10699                 ID HUDID
10700
10701                 Field HUDField
10702
10703                 //mt:if %s.Field == HUDPos
10704                 Pos [2]float32
10705
10706                 //mt:if %s.Field == HUDName
10707                 Name string
10708
10709                 //mt:if %s.Field == HUDScale
10710                 Scale [2]float32
10711
10712                 //mt:if %s.Field == HUDText
10713                 Text string
10714
10715                 //mt:if %s.Field == HUDNumber
10716                 Number uint32
10717
10718                 //mt:if %s.Field == HUDItem
10719                 Item uint32
10720
10721                 //mt:if %s.Field == HUDDir
10722                 Dir uint32
10723
10724                 //mt:if %s.Field == HUDAlign
10725                 Align [2]float32
10726
10727                 //mt:if %s.Field == HUDOffset
10728                 Offset [2]float32
10729
10730                 //mt:if %s.Field == HUDWorldPos
10731                 WorldPos Pos
10732
10733                 //mt:if %s.Field == HUDSize
10734                 Size [2]int32
10735
10736                 //mt:if %s.Field == HUDZIndex
10737                 ZIndex int32
10738
10739                 //mt:if %s.Field == HUDText2
10740                 Text2 string
10741
10742                 //mt:if %s.Field == HUDStyle
10743                 Style HUDStyleFlags
10744         }))(obj)).Field == HUDSize {
10745                 for local185 := range (*(*(struct {
10746                         ID HUDID
10747
10748                         Field HUDField
10749
10750                         //mt:if %s.Field == HUDPos
10751                         Pos [2]float32
10752
10753                         //mt:if %s.Field == HUDName
10754                         Name string
10755
10756                         //mt:if %s.Field == HUDScale
10757                         Scale [2]float32
10758
10759                         //mt:if %s.Field == HUDText
10760                         Text string
10761
10762                         //mt:if %s.Field == HUDNumber
10763                         Number uint32
10764
10765                         //mt:if %s.Field == HUDItem
10766                         Item uint32
10767
10768                         //mt:if %s.Field == HUDDir
10769                         Dir uint32
10770
10771                         //mt:if %s.Field == HUDAlign
10772                         Align [2]float32
10773
10774                         //mt:if %s.Field == HUDOffset
10775                         Offset [2]float32
10776
10777                         //mt:if %s.Field == HUDWorldPos
10778                         WorldPos Pos
10779
10780                         //mt:if %s.Field == HUDSize
10781                         Size [2]int32
10782
10783                         //mt:if %s.Field == HUDZIndex
10784                         ZIndex int32
10785
10786                         //mt:if %s.Field == HUDText2
10787                         Text2 string
10788
10789                         //mt:if %s.Field == HUDStyle
10790                         Style HUDStyleFlags
10791                 }))(obj)).Size {
10792                         {
10793                                 p := &((*(*(struct {
10794                                         ID HUDID
10795
10796                                         Field HUDField
10797
10798                                         //mt:if %s.Field == HUDPos
10799                                         Pos [2]float32
10800
10801                                         //mt:if %s.Field == HUDName
10802                                         Name string
10803
10804                                         //mt:if %s.Field == HUDScale
10805                                         Scale [2]float32
10806
10807                                         //mt:if %s.Field == HUDText
10808                                         Text string
10809
10810                                         //mt:if %s.Field == HUDNumber
10811                                         Number uint32
10812
10813                                         //mt:if %s.Field == HUDItem
10814                                         Item uint32
10815
10816                                         //mt:if %s.Field == HUDDir
10817                                         Dir uint32
10818
10819                                         //mt:if %s.Field == HUDAlign
10820                                         Align [2]float32
10821
10822                                         //mt:if %s.Field == HUDOffset
10823                                         Offset [2]float32
10824
10825                                         //mt:if %s.Field == HUDWorldPos
10826                                         WorldPos Pos
10827
10828                                         //mt:if %s.Field == HUDSize
10829                                         Size [2]int32
10830
10831                                         //mt:if %s.Field == HUDZIndex
10832                                         ZIndex int32
10833
10834                                         //mt:if %s.Field == HUDText2
10835                                         Text2 string
10836
10837                                         //mt:if %s.Field == HUDStyle
10838                                         Style HUDStyleFlags
10839                                 }))(obj)).Size)[local185]
10840                                 *p = int32(read32(r))
10841                         }
10842                 }
10843         }
10844         if (*(*(struct {
10845                 ID HUDID
10846
10847                 Field HUDField
10848
10849                 //mt:if %s.Field == HUDPos
10850                 Pos [2]float32
10851
10852                 //mt:if %s.Field == HUDName
10853                 Name string
10854
10855                 //mt:if %s.Field == HUDScale
10856                 Scale [2]float32
10857
10858                 //mt:if %s.Field == HUDText
10859                 Text string
10860
10861                 //mt:if %s.Field == HUDNumber
10862                 Number uint32
10863
10864                 //mt:if %s.Field == HUDItem
10865                 Item uint32
10866
10867                 //mt:if %s.Field == HUDDir
10868                 Dir uint32
10869
10870                 //mt:if %s.Field == HUDAlign
10871                 Align [2]float32
10872
10873                 //mt:if %s.Field == HUDOffset
10874                 Offset [2]float32
10875
10876                 //mt:if %s.Field == HUDWorldPos
10877                 WorldPos Pos
10878
10879                 //mt:if %s.Field == HUDSize
10880                 Size [2]int32
10881
10882                 //mt:if %s.Field == HUDZIndex
10883                 ZIndex int32
10884
10885                 //mt:if %s.Field == HUDText2
10886                 Text2 string
10887
10888                 //mt:if %s.Field == HUDStyle
10889                 Style HUDStyleFlags
10890         }))(obj)).Field == HUDZIndex {
10891                 {
10892                         p := &(*(*(struct {
10893                                 ID HUDID
10894
10895                                 Field HUDField
10896
10897                                 //mt:if %s.Field == HUDPos
10898                                 Pos [2]float32
10899
10900                                 //mt:if %s.Field == HUDName
10901                                 Name string
10902
10903                                 //mt:if %s.Field == HUDScale
10904                                 Scale [2]float32
10905
10906                                 //mt:if %s.Field == HUDText
10907                                 Text string
10908
10909                                 //mt:if %s.Field == HUDNumber
10910                                 Number uint32
10911
10912                                 //mt:if %s.Field == HUDItem
10913                                 Item uint32
10914
10915                                 //mt:if %s.Field == HUDDir
10916                                 Dir uint32
10917
10918                                 //mt:if %s.Field == HUDAlign
10919                                 Align [2]float32
10920
10921                                 //mt:if %s.Field == HUDOffset
10922                                 Offset [2]float32
10923
10924                                 //mt:if %s.Field == HUDWorldPos
10925                                 WorldPos Pos
10926
10927                                 //mt:if %s.Field == HUDSize
10928                                 Size [2]int32
10929
10930                                 //mt:if %s.Field == HUDZIndex
10931                                 ZIndex int32
10932
10933                                 //mt:if %s.Field == HUDText2
10934                                 Text2 string
10935
10936                                 //mt:if %s.Field == HUDStyle
10937                                 Style HUDStyleFlags
10938                         }))(obj)).ZIndex
10939                         *p = int32(read32(r))
10940                 }
10941         }
10942         if (*(*(struct {
10943                 ID HUDID
10944
10945                 Field HUDField
10946
10947                 //mt:if %s.Field == HUDPos
10948                 Pos [2]float32
10949
10950                 //mt:if %s.Field == HUDName
10951                 Name string
10952
10953                 //mt:if %s.Field == HUDScale
10954                 Scale [2]float32
10955
10956                 //mt:if %s.Field == HUDText
10957                 Text string
10958
10959                 //mt:if %s.Field == HUDNumber
10960                 Number uint32
10961
10962                 //mt:if %s.Field == HUDItem
10963                 Item uint32
10964
10965                 //mt:if %s.Field == HUDDir
10966                 Dir uint32
10967
10968                 //mt:if %s.Field == HUDAlign
10969                 Align [2]float32
10970
10971                 //mt:if %s.Field == HUDOffset
10972                 Offset [2]float32
10973
10974                 //mt:if %s.Field == HUDWorldPos
10975                 WorldPos Pos
10976
10977                 //mt:if %s.Field == HUDSize
10978                 Size [2]int32
10979
10980                 //mt:if %s.Field == HUDZIndex
10981                 ZIndex int32
10982
10983                 //mt:if %s.Field == HUDText2
10984                 Text2 string
10985
10986                 //mt:if %s.Field == HUDStyle
10987                 Style HUDStyleFlags
10988         }))(obj)).Field == HUDText2 {
10989                 var local186 []uint8
10990                 var local187 uint16
10991                 {
10992                         p := &local187
10993                         *p = read16(r)
10994                 }
10995                 (local186) = make([]uint8, local187)
10996                 {
10997                         _, err := io.ReadFull(r, (local186)[:])
10998                         chk(err)
10999                 }
11000                 ((*(*(struct {
11001                         ID HUDID
11002
11003                         Field HUDField
11004
11005                         //mt:if %s.Field == HUDPos
11006                         Pos [2]float32
11007
11008                         //mt:if %s.Field == HUDName
11009                         Name string
11010
11011                         //mt:if %s.Field == HUDScale
11012                         Scale [2]float32
11013
11014                         //mt:if %s.Field == HUDText
11015                         Text string
11016
11017                         //mt:if %s.Field == HUDNumber
11018                         Number uint32
11019
11020                         //mt:if %s.Field == HUDItem
11021                         Item uint32
11022
11023                         //mt:if %s.Field == HUDDir
11024                         Dir uint32
11025
11026                         //mt:if %s.Field == HUDAlign
11027                         Align [2]float32
11028
11029                         //mt:if %s.Field == HUDOffset
11030                         Offset [2]float32
11031
11032                         //mt:if %s.Field == HUDWorldPos
11033                         WorldPos Pos
11034
11035                         //mt:if %s.Field == HUDSize
11036                         Size [2]int32
11037
11038                         //mt:if %s.Field == HUDZIndex
11039                         ZIndex int32
11040
11041                         //mt:if %s.Field == HUDText2
11042                         Text2 string
11043
11044                         //mt:if %s.Field == HUDStyle
11045                         Style HUDStyleFlags
11046                 }))(obj)).Text2) = string(local186)
11047         }
11048         if (*(*(struct {
11049                 ID HUDID
11050
11051                 Field HUDField
11052
11053                 //mt:if %s.Field == HUDPos
11054                 Pos [2]float32
11055
11056                 //mt:if %s.Field == HUDName
11057                 Name string
11058
11059                 //mt:if %s.Field == HUDScale
11060                 Scale [2]float32
11061
11062                 //mt:if %s.Field == HUDText
11063                 Text string
11064
11065                 //mt:if %s.Field == HUDNumber
11066                 Number uint32
11067
11068                 //mt:if %s.Field == HUDItem
11069                 Item uint32
11070
11071                 //mt:if %s.Field == HUDDir
11072                 Dir uint32
11073
11074                 //mt:if %s.Field == HUDAlign
11075                 Align [2]float32
11076
11077                 //mt:if %s.Field == HUDOffset
11078                 Offset [2]float32
11079
11080                 //mt:if %s.Field == HUDWorldPos
11081                 WorldPos Pos
11082
11083                 //mt:if %s.Field == HUDSize
11084                 Size [2]int32
11085
11086                 //mt:if %s.Field == HUDZIndex
11087                 ZIndex int32
11088
11089                 //mt:if %s.Field == HUDText2
11090                 Text2 string
11091
11092                 //mt:if %s.Field == HUDStyle
11093                 Style HUDStyleFlags
11094         }))(obj)).Field == HUDStyle {
11095                 if err := pcall(func() {
11096                         ((*(*(struct {
11097                                 ID HUDID
11098
11099                                 Field HUDField
11100
11101                                 //mt:if %s.Field == HUDPos
11102                                 Pos [2]float32
11103
11104                                 //mt:if %s.Field == HUDName
11105                                 Name string
11106
11107                                 //mt:if %s.Field == HUDScale
11108                                 Scale [2]float32
11109
11110                                 //mt:if %s.Field == HUDText
11111                                 Text string
11112
11113                                 //mt:if %s.Field == HUDNumber
11114                                 Number uint32
11115
11116                                 //mt:if %s.Field == HUDItem
11117                                 Item uint32
11118
11119                                 //mt:if %s.Field == HUDDir
11120                                 Dir uint32
11121
11122                                 //mt:if %s.Field == HUDAlign
11123                                 Align [2]float32
11124
11125                                 //mt:if %s.Field == HUDOffset
11126                                 Offset [2]float32
11127
11128                                 //mt:if %s.Field == HUDWorldPos
11129                                 WorldPos Pos
11130
11131                                 //mt:if %s.Field == HUDSize
11132                                 Size [2]int32
11133
11134                                 //mt:if %s.Field == HUDZIndex
11135                                 ZIndex int32
11136
11137                                 //mt:if %s.Field == HUDText2
11138                                 Text2 string
11139
11140                                 //mt:if %s.Field == HUDStyle
11141                                 Style HUDStyleFlags
11142                         }))(obj)).Style).deserialize(r)
11143                 }); err != nil {
11144                         if err == io.EOF {
11145                                 chk(io.EOF)
11146                         }
11147                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDStyleFlags", err))
11148                 }
11149         }
11150 }
11151
11152 func (obj *ToCltHUDFlags) serialize(w io.Writer) {
11153         if err := pcall(func() {
11154                 ((*(*(struct {
11155                         // &^= Mask
11156                         // |= Flags
11157                         Flags, Mask HUDFlags
11158                 }))(obj)).Flags).serialize(w)
11159         }); err != nil {
11160                 if err == io.EOF {
11161                         chk(io.EOF)
11162                 }
11163                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11164         }
11165         if err := pcall(func() {
11166                 ((*(*(struct {
11167                         // &^= Mask
11168                         // |= Flags
11169                         Flags, Mask HUDFlags
11170                 }))(obj)).Mask).serialize(w)
11171         }); err != nil {
11172                 if err == io.EOF {
11173                         chk(io.EOF)
11174                 }
11175                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11176         }
11177 }
11178
11179 func (obj *ToCltHUDFlags) deserialize(r io.Reader) {
11180         if err := pcall(func() {
11181                 ((*(*(struct {
11182                         // &^= Mask
11183                         // |= Flags
11184                         Flags, Mask HUDFlags
11185                 }))(obj)).Flags).deserialize(r)
11186         }); err != nil {
11187                 if err == io.EOF {
11188                         chk(io.EOF)
11189                 }
11190                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11191         }
11192         if err := pcall(func() {
11193                 ((*(*(struct {
11194                         // &^= Mask
11195                         // |= Flags
11196                         Flags, Mask HUDFlags
11197                 }))(obj)).Mask).deserialize(r)
11198         }); err != nil {
11199                 if err == io.EOF {
11200                         chk(io.EOF)
11201                 }
11202                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDFlags", err))
11203         }
11204 }
11205
11206 func (obj *ToCltSetHotbarParam) serialize(w io.Writer) {
11207         if err := pcall(func() {
11208                 ((*(*(struct {
11209                         Param HotbarParam
11210
11211                         //mt:if %s.Param == HotbarSize
11212                         //mt:const uint16(4) // Size of Size field.
11213                         Size int32
11214
11215                         //mt:if %s.Param != HotbarSize
11216                         Img Texture
11217                 }))(obj)).Param).serialize(w)
11218         }); err != nil {
11219                 if err == io.EOF {
11220                         chk(io.EOF)
11221                 }
11222                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HotbarParam", err))
11223         }
11224         if (*(*(struct {
11225                 Param HotbarParam
11226
11227                 //mt:if %s.Param == HotbarSize
11228                 //mt:const uint16(4) // Size of Size field.
11229                 Size int32
11230
11231                 //mt:if %s.Param != HotbarSize
11232                 Img Texture
11233         }))(obj)).Param == HotbarSize {
11234                 {
11235                         local188 := uint16(4) // Size of Size field.
11236                         {
11237                                 x := local188
11238                                 write16(w, uint16(x))
11239                         }
11240                 }
11241                 {
11242                         x := (*(*(struct {
11243                                 Param HotbarParam
11244
11245                                 //mt:if %s.Param == HotbarSize
11246                                 //mt:const uint16(4) // Size of Size field.
11247                                 Size int32
11248
11249                                 //mt:if %s.Param != HotbarSize
11250                                 Img Texture
11251                         }))(obj)).Size
11252                         write32(w, uint32(x))
11253                 }
11254         }
11255         if (*(*(struct {
11256                 Param HotbarParam
11257
11258                 //mt:if %s.Param == HotbarSize
11259                 //mt:const uint16(4) // Size of Size field.
11260                 Size int32
11261
11262                 //mt:if %s.Param != HotbarSize
11263                 Img Texture
11264         }))(obj)).Param != HotbarSize {
11265                 if err := pcall(func() {
11266                         ((*(*(struct {
11267                                 Param HotbarParam
11268
11269                                 //mt:if %s.Param == HotbarSize
11270                                 //mt:const uint16(4) // Size of Size field.
11271                                 Size int32
11272
11273                                 //mt:if %s.Param != HotbarSize
11274                                 Img Texture
11275                         }))(obj)).Img).serialize(w)
11276                 }); err != nil {
11277                         if err == io.EOF {
11278                                 chk(io.EOF)
11279                         }
11280                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11281                 }
11282         }
11283 }
11284
11285 func (obj *ToCltSetHotbarParam) deserialize(r io.Reader) {
11286         if err := pcall(func() {
11287                 ((*(*(struct {
11288                         Param HotbarParam
11289
11290                         //mt:if %s.Param == HotbarSize
11291                         //mt:const uint16(4) // Size of Size field.
11292                         Size int32
11293
11294                         //mt:if %s.Param != HotbarSize
11295                         Img Texture
11296                 }))(obj)).Param).deserialize(r)
11297         }); err != nil {
11298                 if err == io.EOF {
11299                         chk(io.EOF)
11300                 }
11301                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HotbarParam", err))
11302         }
11303         if (*(*(struct {
11304                 Param HotbarParam
11305
11306                 //mt:if %s.Param == HotbarSize
11307                 //mt:const uint16(4) // Size of Size field.
11308                 Size int32
11309
11310                 //mt:if %s.Param != HotbarSize
11311                 Img Texture
11312         }))(obj)).Param == HotbarSize {
11313                 {
11314                         var local189 uint16
11315                         local190 := uint16(4) // Size of Size field.
11316                         {
11317                                 p := &local189
11318                                 *p = read16(r)
11319                         }
11320                         if local189 != local190 {
11321                                 chk(fmt.Errorf("const %v: %v", "uint16(4) // Size of Size field.", local189))
11322                         }
11323                 }
11324                 {
11325                         p := &(*(*(struct {
11326                                 Param HotbarParam
11327
11328                                 //mt:if %s.Param == HotbarSize
11329                                 //mt:const uint16(4) // Size of Size field.
11330                                 Size int32
11331
11332                                 //mt:if %s.Param != HotbarSize
11333                                 Img Texture
11334                         }))(obj)).Size
11335                         *p = int32(read32(r))
11336                 }
11337         }
11338         if (*(*(struct {
11339                 Param HotbarParam
11340
11341                 //mt:if %s.Param == HotbarSize
11342                 //mt:const uint16(4) // Size of Size field.
11343                 Size int32
11344
11345                 //mt:if %s.Param != HotbarSize
11346                 Img Texture
11347         }))(obj)).Param != HotbarSize {
11348                 if err := pcall(func() {
11349                         ((*(*(struct {
11350                                 Param HotbarParam
11351
11352                                 //mt:if %s.Param == HotbarSize
11353                                 //mt:const uint16(4) // Size of Size field.
11354                                 Size int32
11355
11356                                 //mt:if %s.Param != HotbarSize
11357                                 Img Texture
11358                         }))(obj)).Img).deserialize(r)
11359                 }); err != nil {
11360                         if err == io.EOF {
11361                                 chk(io.EOF)
11362                         }
11363                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11364                 }
11365         }
11366 }
11367
11368 func (obj *ToCltBreath) serialize(w io.Writer) {
11369         {
11370                 x := (*(*(struct {
11371                         Breath uint16
11372                 }))(obj)).Breath
11373                 write16(w, uint16(x))
11374         }
11375 }
11376
11377 func (obj *ToCltBreath) deserialize(r io.Reader) {
11378         {
11379                 p := &(*(*(struct {
11380                         Breath uint16
11381                 }))(obj)).Breath
11382                 *p = read16(r)
11383         }
11384 }
11385
11386 func (obj *ToCltSkyParams) serialize(w io.Writer) {
11387         {
11388                 x := (*(*(struct {
11389                         BgColor     color.NRGBA
11390                         Type        string
11391                         Clouds      bool
11392                         SunFogTint  color.NRGBA
11393                         MoonFogTint color.NRGBA
11394                         FogTintType string
11395
11396                         //mt:if %s.Type == "skybox"
11397                         Textures []Texture
11398
11399                         //mt:if %s.Type == "regular"
11400                         DaySky, DayHorizon,
11401                         DawnSky, DawnHorizon,
11402                         NightSky, NightHorizon,
11403                         Indoor color.NRGBA
11404                 }))(obj)).BgColor
11405                 w.Write([]byte{x.A, x.R, x.G, x.B})
11406         }
11407         if len(([]byte((*(*(struct {
11408                 BgColor     color.NRGBA
11409                 Type        string
11410                 Clouds      bool
11411                 SunFogTint  color.NRGBA
11412                 MoonFogTint color.NRGBA
11413                 FogTintType string
11414
11415                 //mt:if %s.Type == "skybox"
11416                 Textures []Texture
11417
11418                 //mt:if %s.Type == "regular"
11419                 DaySky, DayHorizon,
11420                 DawnSky, DawnHorizon,
11421                 NightSky, NightHorizon,
11422                 Indoor color.NRGBA
11423         }))(obj)).Type))) > math.MaxUint16 {
11424                 chk(ErrTooLong)
11425         }
11426         {
11427                 x := uint16(len(([]byte((*(*(struct {
11428                         BgColor     color.NRGBA
11429                         Type        string
11430                         Clouds      bool
11431                         SunFogTint  color.NRGBA
11432                         MoonFogTint color.NRGBA
11433                         FogTintType string
11434
11435                         //mt:if %s.Type == "skybox"
11436                         Textures []Texture
11437
11438                         //mt:if %s.Type == "regular"
11439                         DaySky, DayHorizon,
11440                         DawnSky, DawnHorizon,
11441                         NightSky, NightHorizon,
11442                         Indoor color.NRGBA
11443                 }))(obj)).Type))))
11444                 write16(w, uint16(x))
11445         }
11446         {
11447                 _, err := w.Write(([]byte((*(*(struct {
11448                         BgColor     color.NRGBA
11449                         Type        string
11450                         Clouds      bool
11451                         SunFogTint  color.NRGBA
11452                         MoonFogTint color.NRGBA
11453                         FogTintType string
11454
11455                         //mt:if %s.Type == "skybox"
11456                         Textures []Texture
11457
11458                         //mt:if %s.Type == "regular"
11459                         DaySky, DayHorizon,
11460                         DawnSky, DawnHorizon,
11461                         NightSky, NightHorizon,
11462                         Indoor color.NRGBA
11463                 }))(obj)).Type))[:])
11464                 chk(err)
11465         }
11466         {
11467                 x := (*(*(struct {
11468                         BgColor     color.NRGBA
11469                         Type        string
11470                         Clouds      bool
11471                         SunFogTint  color.NRGBA
11472                         MoonFogTint color.NRGBA
11473                         FogTintType string
11474
11475                         //mt:if %s.Type == "skybox"
11476                         Textures []Texture
11477
11478                         //mt:if %s.Type == "regular"
11479                         DaySky, DayHorizon,
11480                         DawnSky, DawnHorizon,
11481                         NightSky, NightHorizon,
11482                         Indoor color.NRGBA
11483                 }))(obj)).Clouds
11484                 if x {
11485                         write8(w, 1)
11486                 } else {
11487                         write8(w, 0)
11488                 }
11489         }
11490         {
11491                 x := (*(*(struct {
11492                         BgColor     color.NRGBA
11493                         Type        string
11494                         Clouds      bool
11495                         SunFogTint  color.NRGBA
11496                         MoonFogTint color.NRGBA
11497                         FogTintType string
11498
11499                         //mt:if %s.Type == "skybox"
11500                         Textures []Texture
11501
11502                         //mt:if %s.Type == "regular"
11503                         DaySky, DayHorizon,
11504                         DawnSky, DawnHorizon,
11505                         NightSky, NightHorizon,
11506                         Indoor color.NRGBA
11507                 }))(obj)).SunFogTint
11508                 w.Write([]byte{x.A, x.R, x.G, x.B})
11509         }
11510         {
11511                 x := (*(*(struct {
11512                         BgColor     color.NRGBA
11513                         Type        string
11514                         Clouds      bool
11515                         SunFogTint  color.NRGBA
11516                         MoonFogTint color.NRGBA
11517                         FogTintType string
11518
11519                         //mt:if %s.Type == "skybox"
11520                         Textures []Texture
11521
11522                         //mt:if %s.Type == "regular"
11523                         DaySky, DayHorizon,
11524                         DawnSky, DawnHorizon,
11525                         NightSky, NightHorizon,
11526                         Indoor color.NRGBA
11527                 }))(obj)).MoonFogTint
11528                 w.Write([]byte{x.A, x.R, x.G, x.B})
11529         }
11530         if len(([]byte((*(*(struct {
11531                 BgColor     color.NRGBA
11532                 Type        string
11533                 Clouds      bool
11534                 SunFogTint  color.NRGBA
11535                 MoonFogTint color.NRGBA
11536                 FogTintType string
11537
11538                 //mt:if %s.Type == "skybox"
11539                 Textures []Texture
11540
11541                 //mt:if %s.Type == "regular"
11542                 DaySky, DayHorizon,
11543                 DawnSky, DawnHorizon,
11544                 NightSky, NightHorizon,
11545                 Indoor color.NRGBA
11546         }))(obj)).FogTintType))) > math.MaxUint16 {
11547                 chk(ErrTooLong)
11548         }
11549         {
11550                 x := uint16(len(([]byte((*(*(struct {
11551                         BgColor     color.NRGBA
11552                         Type        string
11553                         Clouds      bool
11554                         SunFogTint  color.NRGBA
11555                         MoonFogTint color.NRGBA
11556                         FogTintType string
11557
11558                         //mt:if %s.Type == "skybox"
11559                         Textures []Texture
11560
11561                         //mt:if %s.Type == "regular"
11562                         DaySky, DayHorizon,
11563                         DawnSky, DawnHorizon,
11564                         NightSky, NightHorizon,
11565                         Indoor color.NRGBA
11566                 }))(obj)).FogTintType))))
11567                 write16(w, uint16(x))
11568         }
11569         {
11570                 _, err := w.Write(([]byte((*(*(struct {
11571                         BgColor     color.NRGBA
11572                         Type        string
11573                         Clouds      bool
11574                         SunFogTint  color.NRGBA
11575                         MoonFogTint color.NRGBA
11576                         FogTintType string
11577
11578                         //mt:if %s.Type == "skybox"
11579                         Textures []Texture
11580
11581                         //mt:if %s.Type == "regular"
11582                         DaySky, DayHorizon,
11583                         DawnSky, DawnHorizon,
11584                         NightSky, NightHorizon,
11585                         Indoor color.NRGBA
11586                 }))(obj)).FogTintType))[:])
11587                 chk(err)
11588         }
11589         if (*(*(struct {
11590                 BgColor     color.NRGBA
11591                 Type        string
11592                 Clouds      bool
11593                 SunFogTint  color.NRGBA
11594                 MoonFogTint color.NRGBA
11595                 FogTintType string
11596
11597                 //mt:if %s.Type == "skybox"
11598                 Textures []Texture
11599
11600                 //mt:if %s.Type == "regular"
11601                 DaySky, DayHorizon,
11602                 DawnSky, DawnHorizon,
11603                 NightSky, NightHorizon,
11604                 Indoor color.NRGBA
11605         }))(obj)).Type == "skybox" {
11606                 if len(((*(*(struct {
11607                         BgColor     color.NRGBA
11608                         Type        string
11609                         Clouds      bool
11610                         SunFogTint  color.NRGBA
11611                         MoonFogTint color.NRGBA
11612                         FogTintType string
11613
11614                         //mt:if %s.Type == "skybox"
11615                         Textures []Texture
11616
11617                         //mt:if %s.Type == "regular"
11618                         DaySky, DayHorizon,
11619                         DawnSky, DawnHorizon,
11620                         NightSky, NightHorizon,
11621                         Indoor color.NRGBA
11622                 }))(obj)).Textures)) > math.MaxUint16 {
11623                         chk(ErrTooLong)
11624                 }
11625                 {
11626                         x := uint16(len(((*(*(struct {
11627                                 BgColor     color.NRGBA
11628                                 Type        string
11629                                 Clouds      bool
11630                                 SunFogTint  color.NRGBA
11631                                 MoonFogTint color.NRGBA
11632                                 FogTintType string
11633
11634                                 //mt:if %s.Type == "skybox"
11635                                 Textures []Texture
11636
11637                                 //mt:if %s.Type == "regular"
11638                                 DaySky, DayHorizon,
11639                                 DawnSky, DawnHorizon,
11640                                 NightSky, NightHorizon,
11641                                 Indoor color.NRGBA
11642                         }))(obj)).Textures)))
11643                         write16(w, uint16(x))
11644                 }
11645                 for local191 := range (*(*(struct {
11646                         BgColor     color.NRGBA
11647                         Type        string
11648                         Clouds      bool
11649                         SunFogTint  color.NRGBA
11650                         MoonFogTint color.NRGBA
11651                         FogTintType string
11652
11653                         //mt:if %s.Type == "skybox"
11654                         Textures []Texture
11655
11656                         //mt:if %s.Type == "regular"
11657                         DaySky, DayHorizon,
11658                         DawnSky, DawnHorizon,
11659                         NightSky, NightHorizon,
11660                         Indoor color.NRGBA
11661                 }))(obj)).Textures {
11662                         if err := pcall(func() {
11663                                 (((*(*(struct {
11664                                         BgColor     color.NRGBA
11665                                         Type        string
11666                                         Clouds      bool
11667                                         SunFogTint  color.NRGBA
11668                                         MoonFogTint color.NRGBA
11669                                         FogTintType string
11670
11671                                         //mt:if %s.Type == "skybox"
11672                                         Textures []Texture
11673
11674                                         //mt:if %s.Type == "regular"
11675                                         DaySky, DayHorizon,
11676                                         DawnSky, DawnHorizon,
11677                                         NightSky, NightHorizon,
11678                                         Indoor color.NRGBA
11679                                 }))(obj)).Textures)[local191]).serialize(w)
11680                         }); err != nil {
11681                                 if err == io.EOF {
11682                                         chk(io.EOF)
11683                                 }
11684                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
11685                         }
11686                 }
11687         }
11688         if (*(*(struct {
11689                 BgColor     color.NRGBA
11690                 Type        string
11691                 Clouds      bool
11692                 SunFogTint  color.NRGBA
11693                 MoonFogTint color.NRGBA
11694                 FogTintType string
11695
11696                 //mt:if %s.Type == "skybox"
11697                 Textures []Texture
11698
11699                 //mt:if %s.Type == "regular"
11700                 DaySky, DayHorizon,
11701                 DawnSky, DawnHorizon,
11702                 NightSky, NightHorizon,
11703                 Indoor color.NRGBA
11704         }))(obj)).Type == "regular" {
11705                 {
11706                         x := (*(*(struct {
11707                                 BgColor     color.NRGBA
11708                                 Type        string
11709                                 Clouds      bool
11710                                 SunFogTint  color.NRGBA
11711                                 MoonFogTint color.NRGBA
11712                                 FogTintType string
11713
11714                                 //mt:if %s.Type == "skybox"
11715                                 Textures []Texture
11716
11717                                 //mt:if %s.Type == "regular"
11718                                 DaySky, DayHorizon,
11719                                 DawnSky, DawnHorizon,
11720                                 NightSky, NightHorizon,
11721                                 Indoor color.NRGBA
11722                         }))(obj)).DaySky
11723                         w.Write([]byte{x.A, x.R, x.G, x.B})
11724                 }
11725                 {
11726                         x := (*(*(struct {
11727                                 BgColor     color.NRGBA
11728                                 Type        string
11729                                 Clouds      bool
11730                                 SunFogTint  color.NRGBA
11731                                 MoonFogTint color.NRGBA
11732                                 FogTintType string
11733
11734                                 //mt:if %s.Type == "skybox"
11735                                 Textures []Texture
11736
11737                                 //mt:if %s.Type == "regular"
11738                                 DaySky, DayHorizon,
11739                                 DawnSky, DawnHorizon,
11740                                 NightSky, NightHorizon,
11741                                 Indoor color.NRGBA
11742                         }))(obj)).DayHorizon
11743                         w.Write([]byte{x.A, x.R, x.G, x.B})
11744                 }
11745                 {
11746                         x := (*(*(struct {
11747                                 BgColor     color.NRGBA
11748                                 Type        string
11749                                 Clouds      bool
11750                                 SunFogTint  color.NRGBA
11751                                 MoonFogTint color.NRGBA
11752                                 FogTintType string
11753
11754                                 //mt:if %s.Type == "skybox"
11755                                 Textures []Texture
11756
11757                                 //mt:if %s.Type == "regular"
11758                                 DaySky, DayHorizon,
11759                                 DawnSky, DawnHorizon,
11760                                 NightSky, NightHorizon,
11761                                 Indoor color.NRGBA
11762                         }))(obj)).DawnSky
11763                         w.Write([]byte{x.A, x.R, x.G, x.B})
11764                 }
11765                 {
11766                         x := (*(*(struct {
11767                                 BgColor     color.NRGBA
11768                                 Type        string
11769                                 Clouds      bool
11770                                 SunFogTint  color.NRGBA
11771                                 MoonFogTint color.NRGBA
11772                                 FogTintType string
11773
11774                                 //mt:if %s.Type == "skybox"
11775                                 Textures []Texture
11776
11777                                 //mt:if %s.Type == "regular"
11778                                 DaySky, DayHorizon,
11779                                 DawnSky, DawnHorizon,
11780                                 NightSky, NightHorizon,
11781                                 Indoor color.NRGBA
11782                         }))(obj)).DawnHorizon
11783                         w.Write([]byte{x.A, x.R, x.G, x.B})
11784                 }
11785                 {
11786                         x := (*(*(struct {
11787                                 BgColor     color.NRGBA
11788                                 Type        string
11789                                 Clouds      bool
11790                                 SunFogTint  color.NRGBA
11791                                 MoonFogTint color.NRGBA
11792                                 FogTintType string
11793
11794                                 //mt:if %s.Type == "skybox"
11795                                 Textures []Texture
11796
11797                                 //mt:if %s.Type == "regular"
11798                                 DaySky, DayHorizon,
11799                                 DawnSky, DawnHorizon,
11800                                 NightSky, NightHorizon,
11801                                 Indoor color.NRGBA
11802                         }))(obj)).NightSky
11803                         w.Write([]byte{x.A, x.R, x.G, x.B})
11804                 }
11805                 {
11806                         x := (*(*(struct {
11807                                 BgColor     color.NRGBA
11808                                 Type        string
11809                                 Clouds      bool
11810                                 SunFogTint  color.NRGBA
11811                                 MoonFogTint color.NRGBA
11812                                 FogTintType string
11813
11814                                 //mt:if %s.Type == "skybox"
11815                                 Textures []Texture
11816
11817                                 //mt:if %s.Type == "regular"
11818                                 DaySky, DayHorizon,
11819                                 DawnSky, DawnHorizon,
11820                                 NightSky, NightHorizon,
11821                                 Indoor color.NRGBA
11822                         }))(obj)).NightHorizon
11823                         w.Write([]byte{x.A, x.R, x.G, x.B})
11824                 }
11825                 {
11826                         x := (*(*(struct {
11827                                 BgColor     color.NRGBA
11828                                 Type        string
11829                                 Clouds      bool
11830                                 SunFogTint  color.NRGBA
11831                                 MoonFogTint color.NRGBA
11832                                 FogTintType string
11833
11834                                 //mt:if %s.Type == "skybox"
11835                                 Textures []Texture
11836
11837                                 //mt:if %s.Type == "regular"
11838                                 DaySky, DayHorizon,
11839                                 DawnSky, DawnHorizon,
11840                                 NightSky, NightHorizon,
11841                                 Indoor color.NRGBA
11842                         }))(obj)).Indoor
11843                         w.Write([]byte{x.A, x.R, x.G, x.B})
11844                 }
11845         }
11846 }
11847
11848 func (obj *ToCltSkyParams) deserialize(r io.Reader) {
11849         {
11850                 p := &(*(*(struct {
11851                         BgColor     color.NRGBA
11852                         Type        string
11853                         Clouds      bool
11854                         SunFogTint  color.NRGBA
11855                         MoonFogTint color.NRGBA
11856                         FogTintType string
11857
11858                         //mt:if %s.Type == "skybox"
11859                         Textures []Texture
11860
11861                         //mt:if %s.Type == "regular"
11862                         DaySky, DayHorizon,
11863                         DawnSky, DawnHorizon,
11864                         NightSky, NightHorizon,
11865                         Indoor color.NRGBA
11866                 }))(obj)).BgColor
11867                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11868         }
11869         var local192 []uint8
11870         var local193 uint16
11871         {
11872                 p := &local193
11873                 *p = read16(r)
11874         }
11875         (local192) = make([]uint8, local193)
11876         {
11877                 _, err := io.ReadFull(r, (local192)[:])
11878                 chk(err)
11879         }
11880         ((*(*(struct {
11881                 BgColor     color.NRGBA
11882                 Type        string
11883                 Clouds      bool
11884                 SunFogTint  color.NRGBA
11885                 MoonFogTint color.NRGBA
11886                 FogTintType string
11887
11888                 //mt:if %s.Type == "skybox"
11889                 Textures []Texture
11890
11891                 //mt:if %s.Type == "regular"
11892                 DaySky, DayHorizon,
11893                 DawnSky, DawnHorizon,
11894                 NightSky, NightHorizon,
11895                 Indoor color.NRGBA
11896         }))(obj)).Type) = string(local192)
11897         {
11898                 p := &(*(*(struct {
11899                         BgColor     color.NRGBA
11900                         Type        string
11901                         Clouds      bool
11902                         SunFogTint  color.NRGBA
11903                         MoonFogTint color.NRGBA
11904                         FogTintType string
11905
11906                         //mt:if %s.Type == "skybox"
11907                         Textures []Texture
11908
11909                         //mt:if %s.Type == "regular"
11910                         DaySky, DayHorizon,
11911                         DawnSky, DawnHorizon,
11912                         NightSky, NightHorizon,
11913                         Indoor color.NRGBA
11914                 }))(obj)).Clouds
11915                 switch n := read8(r); n {
11916                 case 0:
11917                         *p = false
11918                 case 1:
11919                         *p = true
11920                 default:
11921                         chk(fmt.Errorf("invalid bool: %d", n))
11922                 }
11923         }
11924         {
11925                 p := &(*(*(struct {
11926                         BgColor     color.NRGBA
11927                         Type        string
11928                         Clouds      bool
11929                         SunFogTint  color.NRGBA
11930                         MoonFogTint color.NRGBA
11931                         FogTintType string
11932
11933                         //mt:if %s.Type == "skybox"
11934                         Textures []Texture
11935
11936                         //mt:if %s.Type == "regular"
11937                         DaySky, DayHorizon,
11938                         DawnSky, DawnHorizon,
11939                         NightSky, NightHorizon,
11940                         Indoor color.NRGBA
11941                 }))(obj)).SunFogTint
11942                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11943         }
11944         {
11945                 p := &(*(*(struct {
11946                         BgColor     color.NRGBA
11947                         Type        string
11948                         Clouds      bool
11949                         SunFogTint  color.NRGBA
11950                         MoonFogTint color.NRGBA
11951                         FogTintType string
11952
11953                         //mt:if %s.Type == "skybox"
11954                         Textures []Texture
11955
11956                         //mt:if %s.Type == "regular"
11957                         DaySky, DayHorizon,
11958                         DawnSky, DawnHorizon,
11959                         NightSky, NightHorizon,
11960                         Indoor color.NRGBA
11961                 }))(obj)).MoonFogTint
11962                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
11963         }
11964         var local194 []uint8
11965         var local195 uint16
11966         {
11967                 p := &local195
11968                 *p = read16(r)
11969         }
11970         (local194) = make([]uint8, local195)
11971         {
11972                 _, err := io.ReadFull(r, (local194)[:])
11973                 chk(err)
11974         }
11975         ((*(*(struct {
11976                 BgColor     color.NRGBA
11977                 Type        string
11978                 Clouds      bool
11979                 SunFogTint  color.NRGBA
11980                 MoonFogTint color.NRGBA
11981                 FogTintType string
11982
11983                 //mt:if %s.Type == "skybox"
11984                 Textures []Texture
11985
11986                 //mt:if %s.Type == "regular"
11987                 DaySky, DayHorizon,
11988                 DawnSky, DawnHorizon,
11989                 NightSky, NightHorizon,
11990                 Indoor color.NRGBA
11991         }))(obj)).FogTintType) = string(local194)
11992         if (*(*(struct {
11993                 BgColor     color.NRGBA
11994                 Type        string
11995                 Clouds      bool
11996                 SunFogTint  color.NRGBA
11997                 MoonFogTint color.NRGBA
11998                 FogTintType string
11999
12000                 //mt:if %s.Type == "skybox"
12001                 Textures []Texture
12002
12003                 //mt:if %s.Type == "regular"
12004                 DaySky, DayHorizon,
12005                 DawnSky, DawnHorizon,
12006                 NightSky, NightHorizon,
12007                 Indoor color.NRGBA
12008         }))(obj)).Type == "skybox" {
12009                 var local196 uint16
12010                 {
12011                         p := &local196
12012                         *p = read16(r)
12013                 }
12014                 ((*(*(struct {
12015                         BgColor     color.NRGBA
12016                         Type        string
12017                         Clouds      bool
12018                         SunFogTint  color.NRGBA
12019                         MoonFogTint color.NRGBA
12020                         FogTintType string
12021
12022                         //mt:if %s.Type == "skybox"
12023                         Textures []Texture
12024
12025                         //mt:if %s.Type == "regular"
12026                         DaySky, DayHorizon,
12027                         DawnSky, DawnHorizon,
12028                         NightSky, NightHorizon,
12029                         Indoor color.NRGBA
12030                 }))(obj)).Textures) = make([]Texture, local196)
12031                 for local197 := range (*(*(struct {
12032                         BgColor     color.NRGBA
12033                         Type        string
12034                         Clouds      bool
12035                         SunFogTint  color.NRGBA
12036                         MoonFogTint color.NRGBA
12037                         FogTintType string
12038
12039                         //mt:if %s.Type == "skybox"
12040                         Textures []Texture
12041
12042                         //mt:if %s.Type == "regular"
12043                         DaySky, DayHorizon,
12044                         DawnSky, DawnHorizon,
12045                         NightSky, NightHorizon,
12046                         Indoor color.NRGBA
12047                 }))(obj)).Textures {
12048                         if err := pcall(func() {
12049                                 (((*(*(struct {
12050                                         BgColor     color.NRGBA
12051                                         Type        string
12052                                         Clouds      bool
12053                                         SunFogTint  color.NRGBA
12054                                         MoonFogTint color.NRGBA
12055                                         FogTintType string
12056
12057                                         //mt:if %s.Type == "skybox"
12058                                         Textures []Texture
12059
12060                                         //mt:if %s.Type == "regular"
12061                                         DaySky, DayHorizon,
12062                                         DawnSky, DawnHorizon,
12063                                         NightSky, NightHorizon,
12064                                         Indoor color.NRGBA
12065                                 }))(obj)).Textures)[local197]).deserialize(r)
12066                         }); err != nil {
12067                                 if err == io.EOF {
12068                                         chk(io.EOF)
12069                                 }
12070                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
12071                         }
12072                 }
12073         }
12074         if (*(*(struct {
12075                 BgColor     color.NRGBA
12076                 Type        string
12077                 Clouds      bool
12078                 SunFogTint  color.NRGBA
12079                 MoonFogTint color.NRGBA
12080                 FogTintType string
12081
12082                 //mt:if %s.Type == "skybox"
12083                 Textures []Texture
12084
12085                 //mt:if %s.Type == "regular"
12086                 DaySky, DayHorizon,
12087                 DawnSky, DawnHorizon,
12088                 NightSky, NightHorizon,
12089                 Indoor color.NRGBA
12090         }))(obj)).Type == "regular" {
12091                 {
12092                         p := &(*(*(struct {
12093                                 BgColor     color.NRGBA
12094                                 Type        string
12095                                 Clouds      bool
12096                                 SunFogTint  color.NRGBA
12097                                 MoonFogTint color.NRGBA
12098                                 FogTintType string
12099
12100                                 //mt:if %s.Type == "skybox"
12101                                 Textures []Texture
12102
12103                                 //mt:if %s.Type == "regular"
12104                                 DaySky, DayHorizon,
12105                                 DawnSky, DawnHorizon,
12106                                 NightSky, NightHorizon,
12107                                 Indoor color.NRGBA
12108                         }))(obj)).DaySky
12109                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12110                 }
12111                 {
12112                         p := &(*(*(struct {
12113                                 BgColor     color.NRGBA
12114                                 Type        string
12115                                 Clouds      bool
12116                                 SunFogTint  color.NRGBA
12117                                 MoonFogTint color.NRGBA
12118                                 FogTintType string
12119
12120                                 //mt:if %s.Type == "skybox"
12121                                 Textures []Texture
12122
12123                                 //mt:if %s.Type == "regular"
12124                                 DaySky, DayHorizon,
12125                                 DawnSky, DawnHorizon,
12126                                 NightSky, NightHorizon,
12127                                 Indoor color.NRGBA
12128                         }))(obj)).DayHorizon
12129                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12130                 }
12131                 {
12132                         p := &(*(*(struct {
12133                                 BgColor     color.NRGBA
12134                                 Type        string
12135                                 Clouds      bool
12136                                 SunFogTint  color.NRGBA
12137                                 MoonFogTint color.NRGBA
12138                                 FogTintType string
12139
12140                                 //mt:if %s.Type == "skybox"
12141                                 Textures []Texture
12142
12143                                 //mt:if %s.Type == "regular"
12144                                 DaySky, DayHorizon,
12145                                 DawnSky, DawnHorizon,
12146                                 NightSky, NightHorizon,
12147                                 Indoor color.NRGBA
12148                         }))(obj)).DawnSky
12149                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12150                 }
12151                 {
12152                         p := &(*(*(struct {
12153                                 BgColor     color.NRGBA
12154                                 Type        string
12155                                 Clouds      bool
12156                                 SunFogTint  color.NRGBA
12157                                 MoonFogTint color.NRGBA
12158                                 FogTintType string
12159
12160                                 //mt:if %s.Type == "skybox"
12161                                 Textures []Texture
12162
12163                                 //mt:if %s.Type == "regular"
12164                                 DaySky, DayHorizon,
12165                                 DawnSky, DawnHorizon,
12166                                 NightSky, NightHorizon,
12167                                 Indoor color.NRGBA
12168                         }))(obj)).DawnHorizon
12169                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12170                 }
12171                 {
12172                         p := &(*(*(struct {
12173                                 BgColor     color.NRGBA
12174                                 Type        string
12175                                 Clouds      bool
12176                                 SunFogTint  color.NRGBA
12177                                 MoonFogTint color.NRGBA
12178                                 FogTintType string
12179
12180                                 //mt:if %s.Type == "skybox"
12181                                 Textures []Texture
12182
12183                                 //mt:if %s.Type == "regular"
12184                                 DaySky, DayHorizon,
12185                                 DawnSky, DawnHorizon,
12186                                 NightSky, NightHorizon,
12187                                 Indoor color.NRGBA
12188                         }))(obj)).NightSky
12189                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12190                 }
12191                 {
12192                         p := &(*(*(struct {
12193                                 BgColor     color.NRGBA
12194                                 Type        string
12195                                 Clouds      bool
12196                                 SunFogTint  color.NRGBA
12197                                 MoonFogTint color.NRGBA
12198                                 FogTintType string
12199
12200                                 //mt:if %s.Type == "skybox"
12201                                 Textures []Texture
12202
12203                                 //mt:if %s.Type == "regular"
12204                                 DaySky, DayHorizon,
12205                                 DawnSky, DawnHorizon,
12206                                 NightSky, NightHorizon,
12207                                 Indoor color.NRGBA
12208                         }))(obj)).NightHorizon
12209                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12210                 }
12211                 {
12212                         p := &(*(*(struct {
12213                                 BgColor     color.NRGBA
12214                                 Type        string
12215                                 Clouds      bool
12216                                 SunFogTint  color.NRGBA
12217                                 MoonFogTint color.NRGBA
12218                                 FogTintType string
12219
12220                                 //mt:if %s.Type == "skybox"
12221                                 Textures []Texture
12222
12223                                 //mt:if %s.Type == "regular"
12224                                 DaySky, DayHorizon,
12225                                 DawnSky, DawnHorizon,
12226                                 NightSky, NightHorizon,
12227                                 Indoor color.NRGBA
12228                         }))(obj)).Indoor
12229                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12230                 }
12231         }
12232 }
12233
12234 func (obj *ToCltOverrideDayNightRatio) serialize(w io.Writer) {
12235         {
12236                 x := (*(*(struct {
12237                         Override bool
12238                         Ratio    uint16
12239                 }))(obj)).Override
12240                 if x {
12241                         write8(w, 1)
12242                 } else {
12243                         write8(w, 0)
12244                 }
12245         }
12246         {
12247                 x := (*(*(struct {
12248                         Override bool
12249                         Ratio    uint16
12250                 }))(obj)).Ratio
12251                 write16(w, uint16(x))
12252         }
12253 }
12254
12255 func (obj *ToCltOverrideDayNightRatio) deserialize(r io.Reader) {
12256         {
12257                 p := &(*(*(struct {
12258                         Override bool
12259                         Ratio    uint16
12260                 }))(obj)).Override
12261                 switch n := read8(r); n {
12262                 case 0:
12263                         *p = false
12264                 case 1:
12265                         *p = true
12266                 default:
12267                         chk(fmt.Errorf("invalid bool: %d", n))
12268                 }
12269         }
12270         {
12271                 p := &(*(*(struct {
12272                         Override bool
12273                         Ratio    uint16
12274                 }))(obj)).Ratio
12275                 *p = read16(r)
12276         }
12277 }
12278
12279 func (obj *ToCltLocalPlayerAnim) serialize(w io.Writer) {
12280         for local198 := range (*(*(struct {
12281                 Idle, Walk, Dig, WalkDig [2]int32
12282                 Speed                    float32
12283         }))(obj)).Idle {
12284                 {
12285                         x := ((*(*(struct {
12286                                 Idle, Walk, Dig, WalkDig [2]int32
12287                                 Speed                    float32
12288                         }))(obj)).Idle)[local198]
12289                         write32(w, uint32(x))
12290                 }
12291         }
12292         for local199 := range (*(*(struct {
12293                 Idle, Walk, Dig, WalkDig [2]int32
12294                 Speed                    float32
12295         }))(obj)).Walk {
12296                 {
12297                         x := ((*(*(struct {
12298                                 Idle, Walk, Dig, WalkDig [2]int32
12299                                 Speed                    float32
12300                         }))(obj)).Walk)[local199]
12301                         write32(w, uint32(x))
12302                 }
12303         }
12304         for local200 := range (*(*(struct {
12305                 Idle, Walk, Dig, WalkDig [2]int32
12306                 Speed                    float32
12307         }))(obj)).Dig {
12308                 {
12309                         x := ((*(*(struct {
12310                                 Idle, Walk, Dig, WalkDig [2]int32
12311                                 Speed                    float32
12312                         }))(obj)).Dig)[local200]
12313                         write32(w, uint32(x))
12314                 }
12315         }
12316         for local201 := range (*(*(struct {
12317                 Idle, Walk, Dig, WalkDig [2]int32
12318                 Speed                    float32
12319         }))(obj)).WalkDig {
12320                 {
12321                         x := ((*(*(struct {
12322                                 Idle, Walk, Dig, WalkDig [2]int32
12323                                 Speed                    float32
12324                         }))(obj)).WalkDig)[local201]
12325                         write32(w, uint32(x))
12326                 }
12327         }
12328         {
12329                 x := (*(*(struct {
12330                         Idle, Walk, Dig, WalkDig [2]int32
12331                         Speed                    float32
12332                 }))(obj)).Speed
12333                 write32(w, math.Float32bits(x))
12334         }
12335 }
12336
12337 func (obj *ToCltLocalPlayerAnim) deserialize(r io.Reader) {
12338         for local202 := range (*(*(struct {
12339                 Idle, Walk, Dig, WalkDig [2]int32
12340                 Speed                    float32
12341         }))(obj)).Idle {
12342                 {
12343                         p := &((*(*(struct {
12344                                 Idle, Walk, Dig, WalkDig [2]int32
12345                                 Speed                    float32
12346                         }))(obj)).Idle)[local202]
12347                         *p = int32(read32(r))
12348                 }
12349         }
12350         for local203 := range (*(*(struct {
12351                 Idle, Walk, Dig, WalkDig [2]int32
12352                 Speed                    float32
12353         }))(obj)).Walk {
12354                 {
12355                         p := &((*(*(struct {
12356                                 Idle, Walk, Dig, WalkDig [2]int32
12357                                 Speed                    float32
12358                         }))(obj)).Walk)[local203]
12359                         *p = int32(read32(r))
12360                 }
12361         }
12362         for local204 := range (*(*(struct {
12363                 Idle, Walk, Dig, WalkDig [2]int32
12364                 Speed                    float32
12365         }))(obj)).Dig {
12366                 {
12367                         p := &((*(*(struct {
12368                                 Idle, Walk, Dig, WalkDig [2]int32
12369                                 Speed                    float32
12370                         }))(obj)).Dig)[local204]
12371                         *p = int32(read32(r))
12372                 }
12373         }
12374         for local205 := range (*(*(struct {
12375                 Idle, Walk, Dig, WalkDig [2]int32
12376                 Speed                    float32
12377         }))(obj)).WalkDig {
12378                 {
12379                         p := &((*(*(struct {
12380                                 Idle, Walk, Dig, WalkDig [2]int32
12381                                 Speed                    float32
12382                         }))(obj)).WalkDig)[local205]
12383                         *p = int32(read32(r))
12384                 }
12385         }
12386         {
12387                 p := &(*(*(struct {
12388                         Idle, Walk, Dig, WalkDig [2]int32
12389                         Speed                    float32
12390                 }))(obj)).Speed
12391                 *p = math.Float32frombits(read32(r))
12392         }
12393 }
12394
12395 func (obj *ToCltEyeOffset) serialize(w io.Writer) {
12396         if err := pcall(func() {
12397                 ((*(*(struct {
12398                         First, Third Vec
12399                 }))(obj)).First).serialize(w)
12400         }); err != nil {
12401                 if err == io.EOF {
12402                         chk(io.EOF)
12403                 }
12404                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12405         }
12406         if err := pcall(func() {
12407                 ((*(*(struct {
12408                         First, Third Vec
12409                 }))(obj)).Third).serialize(w)
12410         }); err != nil {
12411                 if err == io.EOF {
12412                         chk(io.EOF)
12413                 }
12414                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12415         }
12416 }
12417
12418 func (obj *ToCltEyeOffset) deserialize(r io.Reader) {
12419         if err := pcall(func() {
12420                 ((*(*(struct {
12421                         First, Third Vec
12422                 }))(obj)).First).deserialize(r)
12423         }); err != nil {
12424                 if err == io.EOF {
12425                         chk(io.EOF)
12426                 }
12427                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12428         }
12429         if err := pcall(func() {
12430                 ((*(*(struct {
12431                         First, Third Vec
12432                 }))(obj)).Third).deserialize(r)
12433         }); err != nil {
12434                 if err == io.EOF {
12435                         chk(io.EOF)
12436                 }
12437                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
12438         }
12439 }
12440
12441 func (obj *ToCltDelParticleSpawner) serialize(w io.Writer) {
12442         if err := pcall(func() {
12443                 ((*(*(struct {
12444                         ID ParticleSpawnerID
12445                 }))(obj)).ID).serialize(w)
12446         }); err != nil {
12447                 if err == io.EOF {
12448                         chk(io.EOF)
12449                 }
12450                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
12451         }
12452 }
12453
12454 func (obj *ToCltDelParticleSpawner) deserialize(r io.Reader) {
12455         if err := pcall(func() {
12456                 ((*(*(struct {
12457                         ID ParticleSpawnerID
12458                 }))(obj)).ID).deserialize(r)
12459         }); err != nil {
12460                 if err == io.EOF {
12461                         chk(io.EOF)
12462                 }
12463                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ParticleSpawnerID", err))
12464         }
12465 }
12466
12467 func (obj *ToCltCloudParams) serialize(w io.Writer) {
12468         {
12469                 x := (*(*(struct {
12470                         Density      float32
12471                         DiffuseColor color.NRGBA
12472                         AmbientColor color.NRGBA
12473                         Height       float32
12474                         Thickness    float32
12475                         Speed        [2]float32
12476                 }))(obj)).Density
12477                 write32(w, math.Float32bits(x))
12478         }
12479         {
12480                 x := (*(*(struct {
12481                         Density      float32
12482                         DiffuseColor color.NRGBA
12483                         AmbientColor color.NRGBA
12484                         Height       float32
12485                         Thickness    float32
12486                         Speed        [2]float32
12487                 }))(obj)).DiffuseColor
12488                 w.Write([]byte{x.A, x.R, x.G, x.B})
12489         }
12490         {
12491                 x := (*(*(struct {
12492                         Density      float32
12493                         DiffuseColor color.NRGBA
12494                         AmbientColor color.NRGBA
12495                         Height       float32
12496                         Thickness    float32
12497                         Speed        [2]float32
12498                 }))(obj)).AmbientColor
12499                 w.Write([]byte{x.A, x.R, x.G, x.B})
12500         }
12501         {
12502                 x := (*(*(struct {
12503                         Density      float32
12504                         DiffuseColor color.NRGBA
12505                         AmbientColor color.NRGBA
12506                         Height       float32
12507                         Thickness    float32
12508                         Speed        [2]float32
12509                 }))(obj)).Height
12510                 write32(w, math.Float32bits(x))
12511         }
12512         {
12513                 x := (*(*(struct {
12514                         Density      float32
12515                         DiffuseColor color.NRGBA
12516                         AmbientColor color.NRGBA
12517                         Height       float32
12518                         Thickness    float32
12519                         Speed        [2]float32
12520                 }))(obj)).Thickness
12521                 write32(w, math.Float32bits(x))
12522         }
12523         for local206 := range (*(*(struct {
12524                 Density      float32
12525                 DiffuseColor color.NRGBA
12526                 AmbientColor color.NRGBA
12527                 Height       float32
12528                 Thickness    float32
12529                 Speed        [2]float32
12530         }))(obj)).Speed {
12531                 {
12532                         x := ((*(*(struct {
12533                                 Density      float32
12534                                 DiffuseColor color.NRGBA
12535                                 AmbientColor color.NRGBA
12536                                 Height       float32
12537                                 Thickness    float32
12538                                 Speed        [2]float32
12539                         }))(obj)).Speed)[local206]
12540                         write32(w, math.Float32bits(x))
12541                 }
12542         }
12543 }
12544
12545 func (obj *ToCltCloudParams) deserialize(r io.Reader) {
12546         {
12547                 p := &(*(*(struct {
12548                         Density      float32
12549                         DiffuseColor color.NRGBA
12550                         AmbientColor color.NRGBA
12551                         Height       float32
12552                         Thickness    float32
12553                         Speed        [2]float32
12554                 }))(obj)).Density
12555                 *p = math.Float32frombits(read32(r))
12556         }
12557         {
12558                 p := &(*(*(struct {
12559                         Density      float32
12560                         DiffuseColor color.NRGBA
12561                         AmbientColor color.NRGBA
12562                         Height       float32
12563                         Thickness    float32
12564                         Speed        [2]float32
12565                 }))(obj)).DiffuseColor
12566                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12567         }
12568         {
12569                 p := &(*(*(struct {
12570                         Density      float32
12571                         DiffuseColor color.NRGBA
12572                         AmbientColor color.NRGBA
12573                         Height       float32
12574                         Thickness    float32
12575                         Speed        [2]float32
12576                 }))(obj)).AmbientColor
12577                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
12578         }
12579         {
12580                 p := &(*(*(struct {
12581                         Density      float32
12582                         DiffuseColor color.NRGBA
12583                         AmbientColor color.NRGBA
12584                         Height       float32
12585                         Thickness    float32
12586                         Speed        [2]float32
12587                 }))(obj)).Height
12588                 *p = math.Float32frombits(read32(r))
12589         }
12590         {
12591                 p := &(*(*(struct {
12592                         Density      float32
12593                         DiffuseColor color.NRGBA
12594                         AmbientColor color.NRGBA
12595                         Height       float32
12596                         Thickness    float32
12597                         Speed        [2]float32
12598                 }))(obj)).Thickness
12599                 *p = math.Float32frombits(read32(r))
12600         }
12601         for local207 := range (*(*(struct {
12602                 Density      float32
12603                 DiffuseColor color.NRGBA
12604                 AmbientColor color.NRGBA
12605                 Height       float32
12606                 Thickness    float32
12607                 Speed        [2]float32
12608         }))(obj)).Speed {
12609                 {
12610                         p := &((*(*(struct {
12611                                 Density      float32
12612                                 DiffuseColor color.NRGBA
12613                                 AmbientColor color.NRGBA
12614                                 Height       float32
12615                                 Thickness    float32
12616                                 Speed        [2]float32
12617                         }))(obj)).Speed)[local207]
12618                         *p = math.Float32frombits(read32(r))
12619                 }
12620         }
12621 }
12622
12623 func (obj *ToCltFadeSound) serialize(w io.Writer) {
12624         if err := pcall(func() {
12625                 ((*(*(struct {
12626                         ID   SoundID
12627                         Step float32
12628                         Gain float32
12629                 }))(obj)).ID).serialize(w)
12630         }); err != nil {
12631                 if err == io.EOF {
12632                         chk(io.EOF)
12633                 }
12634                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
12635         }
12636         {
12637                 x := (*(*(struct {
12638                         ID   SoundID
12639                         Step float32
12640                         Gain float32
12641                 }))(obj)).Step
12642                 write32(w, math.Float32bits(x))
12643         }
12644         {
12645                 x := (*(*(struct {
12646                         ID   SoundID
12647                         Step float32
12648                         Gain float32
12649                 }))(obj)).Gain
12650                 write32(w, math.Float32bits(x))
12651         }
12652 }
12653
12654 func (obj *ToCltFadeSound) deserialize(r io.Reader) {
12655         if err := pcall(func() {
12656                 ((*(*(struct {
12657                         ID   SoundID
12658                         Step float32
12659                         Gain float32
12660                 }))(obj)).ID).deserialize(r)
12661         }); err != nil {
12662                 if err == io.EOF {
12663                         chk(io.EOF)
12664                 }
12665                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundID", err))
12666         }
12667         {
12668                 p := &(*(*(struct {
12669                         ID   SoundID
12670                         Step float32
12671                         Gain float32
12672                 }))(obj)).Step
12673                 *p = math.Float32frombits(read32(r))
12674         }
12675         {
12676                 p := &(*(*(struct {
12677                         ID   SoundID
12678                         Step float32
12679                         Gain float32
12680                 }))(obj)).Gain
12681                 *p = math.Float32frombits(read32(r))
12682         }
12683 }
12684
12685 func (obj *ToCltUpdatePlayerList) serialize(w io.Writer) {
12686         if err := pcall(func() {
12687                 ((*(*(struct {
12688                         Type    PlayerListUpdateType
12689                         Players []string
12690                 }))(obj)).Type).serialize(w)
12691         }); err != nil {
12692                 if err == io.EOF {
12693                         chk(io.EOF)
12694                 }
12695                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerListUpdateType", err))
12696         }
12697         if len(((*(*(struct {
12698                 Type    PlayerListUpdateType
12699                 Players []string
12700         }))(obj)).Players)) > math.MaxUint16 {
12701                 chk(ErrTooLong)
12702         }
12703         {
12704                 x := uint16(len(((*(*(struct {
12705                         Type    PlayerListUpdateType
12706                         Players []string
12707                 }))(obj)).Players)))
12708                 write16(w, uint16(x))
12709         }
12710         for local208 := range (*(*(struct {
12711                 Type    PlayerListUpdateType
12712                 Players []string
12713         }))(obj)).Players {
12714                 if len(([]byte(((*(*(struct {
12715                         Type    PlayerListUpdateType
12716                         Players []string
12717                 }))(obj)).Players)[local208]))) > math.MaxUint16 {
12718                         chk(ErrTooLong)
12719                 }
12720                 {
12721                         x := uint16(len(([]byte(((*(*(struct {
12722                                 Type    PlayerListUpdateType
12723                                 Players []string
12724                         }))(obj)).Players)[local208]))))
12725                         write16(w, uint16(x))
12726                 }
12727                 {
12728                         _, err := w.Write(([]byte(((*(*(struct {
12729                                 Type    PlayerListUpdateType
12730                                 Players []string
12731                         }))(obj)).Players)[local208]))[:])
12732                         chk(err)
12733                 }
12734         }
12735 }
12736
12737 func (obj *ToCltUpdatePlayerList) deserialize(r io.Reader) {
12738         if err := pcall(func() {
12739                 ((*(*(struct {
12740                         Type    PlayerListUpdateType
12741                         Players []string
12742                 }))(obj)).Type).deserialize(r)
12743         }); err != nil {
12744                 if err == io.EOF {
12745                         chk(io.EOF)
12746                 }
12747                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.PlayerListUpdateType", err))
12748         }
12749         var local209 uint16
12750         {
12751                 p := &local209
12752                 *p = read16(r)
12753         }
12754         ((*(*(struct {
12755                 Type    PlayerListUpdateType
12756                 Players []string
12757         }))(obj)).Players) = make([]string, local209)
12758         for local210 := range (*(*(struct {
12759                 Type    PlayerListUpdateType
12760                 Players []string
12761         }))(obj)).Players {
12762                 var local211 []uint8
12763                 var local212 uint16
12764                 {
12765                         p := &local212
12766                         *p = read16(r)
12767                 }
12768                 (local211) = make([]uint8, local212)
12769                 {
12770                         _, err := io.ReadFull(r, (local211)[:])
12771                         chk(err)
12772                 }
12773                 (((*(*(struct {
12774                         Type    PlayerListUpdateType
12775                         Players []string
12776                 }))(obj)).Players)[local210]) = string(local211)
12777         }
12778 }
12779
12780 func (obj *ToCltModChanMsg) serialize(w io.Writer) {
12781         if len(([]byte((*(*(struct {
12782                 Channel string
12783                 Sender  string
12784                 Msg     string
12785         }))(obj)).Channel))) > math.MaxUint16 {
12786                 chk(ErrTooLong)
12787         }
12788         {
12789                 x := uint16(len(([]byte((*(*(struct {
12790                         Channel string
12791                         Sender  string
12792                         Msg     string
12793                 }))(obj)).Channel))))
12794                 write16(w, uint16(x))
12795         }
12796         {
12797                 _, err := w.Write(([]byte((*(*(struct {
12798                         Channel string
12799                         Sender  string
12800                         Msg     string
12801                 }))(obj)).Channel))[:])
12802                 chk(err)
12803         }
12804         if len(([]byte((*(*(struct {
12805                 Channel string
12806                 Sender  string
12807                 Msg     string
12808         }))(obj)).Sender))) > math.MaxUint16 {
12809                 chk(ErrTooLong)
12810         }
12811         {
12812                 x := uint16(len(([]byte((*(*(struct {
12813                         Channel string
12814                         Sender  string
12815                         Msg     string
12816                 }))(obj)).Sender))))
12817                 write16(w, uint16(x))
12818         }
12819         {
12820                 _, err := w.Write(([]byte((*(*(struct {
12821                         Channel string
12822                         Sender  string
12823                         Msg     string
12824                 }))(obj)).Sender))[:])
12825                 chk(err)
12826         }
12827         if len(([]byte((*(*(struct {
12828                 Channel string
12829                 Sender  string
12830                 Msg     string
12831         }))(obj)).Msg))) > math.MaxUint16 {
12832                 chk(ErrTooLong)
12833         }
12834         {
12835                 x := uint16(len(([]byte((*(*(struct {
12836                         Channel string
12837                         Sender  string
12838                         Msg     string
12839                 }))(obj)).Msg))))
12840                 write16(w, uint16(x))
12841         }
12842         {
12843                 _, err := w.Write(([]byte((*(*(struct {
12844                         Channel string
12845                         Sender  string
12846                         Msg     string
12847                 }))(obj)).Msg))[:])
12848                 chk(err)
12849         }
12850 }
12851
12852 func (obj *ToCltModChanMsg) deserialize(r io.Reader) {
12853         var local213 []uint8
12854         var local214 uint16
12855         {
12856                 p := &local214
12857                 *p = read16(r)
12858         }
12859         (local213) = make([]uint8, local214)
12860         {
12861                 _, err := io.ReadFull(r, (local213)[:])
12862                 chk(err)
12863         }
12864         ((*(*(struct {
12865                 Channel string
12866                 Sender  string
12867                 Msg     string
12868         }))(obj)).Channel) = string(local213)
12869         var local215 []uint8
12870         var local216 uint16
12871         {
12872                 p := &local216
12873                 *p = read16(r)
12874         }
12875         (local215) = make([]uint8, local216)
12876         {
12877                 _, err := io.ReadFull(r, (local215)[:])
12878                 chk(err)
12879         }
12880         ((*(*(struct {
12881                 Channel string
12882                 Sender  string
12883                 Msg     string
12884         }))(obj)).Sender) = string(local215)
12885         var local217 []uint8
12886         var local218 uint16
12887         {
12888                 p := &local218
12889                 *p = read16(r)
12890         }
12891         (local217) = make([]uint8, local218)
12892         {
12893                 _, err := io.ReadFull(r, (local217)[:])
12894                 chk(err)
12895         }
12896         ((*(*(struct {
12897                 Channel string
12898                 Sender  string
12899                 Msg     string
12900         }))(obj)).Msg) = string(local217)
12901 }
12902
12903 func (obj *ToCltModChanSig) serialize(w io.Writer) {
12904         if err := pcall(func() {
12905                 ((*(*(struct {
12906                         Signal  ModChanSig
12907                         Channel string
12908                 }))(obj)).Signal).serialize(w)
12909         }); err != nil {
12910                 if err == io.EOF {
12911                         chk(io.EOF)
12912                 }
12913                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ModChanSig", err))
12914         }
12915         if len(([]byte((*(*(struct {
12916                 Signal  ModChanSig
12917                 Channel string
12918         }))(obj)).Channel))) > math.MaxUint16 {
12919                 chk(ErrTooLong)
12920         }
12921         {
12922                 x := uint16(len(([]byte((*(*(struct {
12923                         Signal  ModChanSig
12924                         Channel string
12925                 }))(obj)).Channel))))
12926                 write16(w, uint16(x))
12927         }
12928         {
12929                 _, err := w.Write(([]byte((*(*(struct {
12930                         Signal  ModChanSig
12931                         Channel string
12932                 }))(obj)).Channel))[:])
12933                 chk(err)
12934         }
12935 }
12936
12937 func (obj *ToCltModChanSig) deserialize(r io.Reader) {
12938         if err := pcall(func() {
12939                 ((*(*(struct {
12940                         Signal  ModChanSig
12941                         Channel string
12942                 }))(obj)).Signal).deserialize(r)
12943         }); err != nil {
12944                 if err == io.EOF {
12945                         chk(io.EOF)
12946                 }
12947                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ModChanSig", err))
12948         }
12949         var local219 []uint8
12950         var local220 uint16
12951         {
12952                 p := &local220
12953                 *p = read16(r)
12954         }
12955         (local219) = make([]uint8, local220)
12956         {
12957                 _, err := io.ReadFull(r, (local219)[:])
12958                 chk(err)
12959         }
12960         ((*(*(struct {
12961                 Signal  ModChanSig
12962                 Channel string
12963         }))(obj)).Channel) = string(local219)
12964 }
12965
12966 func (obj *ToCltNodeMetasChanged) serialize(w io.Writer) {
12967         {
12968                 ow := w
12969                 w := new(bytes.Buffer)
12970                 {
12971                         x := (*(*(struct {
12972                                 //mt:lenhdr 32
12973                                 Changed map[[3]int16]*NodeMeta
12974                         }))(obj)).Changed
12975                         {
12976                                 w := zlib.NewWriter(w)
12977                                 if x == nil {
12978                                         write8(w, 0)
12979                                 } else {
12980                                         write8(w, 2)
12981                                         if len(x) > math.MaxUint16 {
12982                                                 chk(ErrTooLong)
12983                                         }
12984                                         write16(w, uint16(len(x)))
12985                                         keys := make([][3]int16, 0, len(x))
12986                                         for key := range x {
12987                                                 keys = append(keys, key)
12988                                         }
12989                                         sort.Slice(keys, func(i, j int) bool {
12990                                                 p, q := keys[i], keys[j]
12991                                                 for i := range p {
12992                                                         switch {
12993                                                         case p[i] < q[i]:
12994                                                                 return true
12995                                                         case p[i] > q[i]:
12996                                                                 return false
12997                                                         }
12998                                                 }
12999                                                 return false
13000                                         })
13001                                         for _, key := range keys {
13002                                                 for _, n := range key {
13003                                                         write16(w, uint16(n))
13004                                                 }
13005                                                 chk(serialize(w, x[key]))
13006                                         }
13007                                 }
13008                                 chk(w.Close())
13009                         }
13010                 }
13011                 {
13012                         buf := w
13013                         w := ow
13014                         if len((buf.Bytes())) > math.MaxUint32 {
13015                                 chk(ErrTooLong)
13016                         }
13017                         {
13018                                 x := uint32(len((buf.Bytes())))
13019                                 write32(w, uint32(x))
13020                         }
13021                         {
13022                                 _, err := w.Write((buf.Bytes())[:])
13023                                 chk(err)
13024                         }
13025                 }
13026         }
13027 }
13028
13029 func (obj *ToCltNodeMetasChanged) deserialize(r io.Reader) {
13030         {
13031                 var n uint32
13032                 {
13033                         p := &n
13034                         *p = read32(r)
13035                 }
13036                 r := &io.LimitedReader{R: r, N: int64(n)}
13037                 {
13038                         p := &(*(*(struct {
13039                                 //mt:lenhdr 32
13040                                 Changed map[[3]int16]*NodeMeta
13041                         }))(obj)).Changed
13042                         {
13043                                 r, err := zlib.NewReader(byteReader{r})
13044                                 chk(err)
13045                                 switch ver := read8(r); ver {
13046                                 case 0:
13047                                         *p = nil
13048                                 case 2:
13049                                         n := read16(r)
13050                                         *p = make(map[[3]int16]*NodeMeta, n)
13051                                         for ; n > 0; n-- {
13052                                                 var pos [3]int16
13053                                                 for i := range pos {
13054                                                         pos[i] = int16(read16(r))
13055                                                 }
13056                                                 nm := new(NodeMeta)
13057                                                 chk(deserialize(r, nm))
13058                                                 (*p)[pos] = nm
13059                                         }
13060                                 default:
13061                                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
13062                                 }
13063                                 chk(r.Close())
13064                         }
13065                 }
13066                 if r.N > 0 {
13067                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
13068                 }
13069         }
13070 }
13071
13072 func (obj *ToCltSunParams) serialize(w io.Writer) {
13073         {
13074                 x := (*(*(struct {
13075                         Visible bool
13076                         Texture
13077                         ToneMap Texture
13078                         Rise    Texture
13079                         Rising  bool
13080                         Size    float32
13081                 }))(obj)).Visible
13082                 if x {
13083                         write8(w, 1)
13084                 } else {
13085                         write8(w, 0)
13086                 }
13087         }
13088         if err := pcall(func() {
13089                 ((*(*(struct {
13090                         Visible bool
13091                         Texture
13092                         ToneMap Texture
13093                         Rise    Texture
13094                         Rising  bool
13095                         Size    float32
13096                 }))(obj)).Texture).serialize(w)
13097         }); err != nil {
13098                 if err == io.EOF {
13099                         chk(io.EOF)
13100                 }
13101                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13102         }
13103         if err := pcall(func() {
13104                 ((*(*(struct {
13105                         Visible bool
13106                         Texture
13107                         ToneMap Texture
13108                         Rise    Texture
13109                         Rising  bool
13110                         Size    float32
13111                 }))(obj)).ToneMap).serialize(w)
13112         }); err != nil {
13113                 if err == io.EOF {
13114                         chk(io.EOF)
13115                 }
13116                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13117         }
13118         if err := pcall(func() {
13119                 ((*(*(struct {
13120                         Visible bool
13121                         Texture
13122                         ToneMap Texture
13123                         Rise    Texture
13124                         Rising  bool
13125                         Size    float32
13126                 }))(obj)).Rise).serialize(w)
13127         }); err != nil {
13128                 if err == io.EOF {
13129                         chk(io.EOF)
13130                 }
13131                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13132         }
13133         {
13134                 x := (*(*(struct {
13135                         Visible bool
13136                         Texture
13137                         ToneMap Texture
13138                         Rise    Texture
13139                         Rising  bool
13140                         Size    float32
13141                 }))(obj)).Rising
13142                 if x {
13143                         write8(w, 1)
13144                 } else {
13145                         write8(w, 0)
13146                 }
13147         }
13148         {
13149                 x := (*(*(struct {
13150                         Visible bool
13151                         Texture
13152                         ToneMap Texture
13153                         Rise    Texture
13154                         Rising  bool
13155                         Size    float32
13156                 }))(obj)).Size
13157                 write32(w, math.Float32bits(x))
13158         }
13159 }
13160
13161 func (obj *ToCltSunParams) deserialize(r io.Reader) {
13162         {
13163                 p := &(*(*(struct {
13164                         Visible bool
13165                         Texture
13166                         ToneMap Texture
13167                         Rise    Texture
13168                         Rising  bool
13169                         Size    float32
13170                 }))(obj)).Visible
13171                 switch n := read8(r); n {
13172                 case 0:
13173                         *p = false
13174                 case 1:
13175                         *p = true
13176                 default:
13177                         chk(fmt.Errorf("invalid bool: %d", n))
13178                 }
13179         }
13180         if err := pcall(func() {
13181                 ((*(*(struct {
13182                         Visible bool
13183                         Texture
13184                         ToneMap Texture
13185                         Rise    Texture
13186                         Rising  bool
13187                         Size    float32
13188                 }))(obj)).Texture).deserialize(r)
13189         }); err != nil {
13190                 if err == io.EOF {
13191                         chk(io.EOF)
13192                 }
13193                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13194         }
13195         if err := pcall(func() {
13196                 ((*(*(struct {
13197                         Visible bool
13198                         Texture
13199                         ToneMap Texture
13200                         Rise    Texture
13201                         Rising  bool
13202                         Size    float32
13203                 }))(obj)).ToneMap).deserialize(r)
13204         }); err != nil {
13205                 if err == io.EOF {
13206                         chk(io.EOF)
13207                 }
13208                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13209         }
13210         if err := pcall(func() {
13211                 ((*(*(struct {
13212                         Visible bool
13213                         Texture
13214                         ToneMap Texture
13215                         Rise    Texture
13216                         Rising  bool
13217                         Size    float32
13218                 }))(obj)).Rise).deserialize(r)
13219         }); err != nil {
13220                 if err == io.EOF {
13221                         chk(io.EOF)
13222                 }
13223                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13224         }
13225         {
13226                 p := &(*(*(struct {
13227                         Visible bool
13228                         Texture
13229                         ToneMap Texture
13230                         Rise    Texture
13231                         Rising  bool
13232                         Size    float32
13233                 }))(obj)).Rising
13234                 switch n := read8(r); n {
13235                 case 0:
13236                         *p = false
13237                 case 1:
13238                         *p = true
13239                 default:
13240                         chk(fmt.Errorf("invalid bool: %d", n))
13241                 }
13242         }
13243         {
13244                 p := &(*(*(struct {
13245                         Visible bool
13246                         Texture
13247                         ToneMap Texture
13248                         Rise    Texture
13249                         Rising  bool
13250                         Size    float32
13251                 }))(obj)).Size
13252                 *p = math.Float32frombits(read32(r))
13253         }
13254 }
13255
13256 func (obj *ToCltMoonParams) serialize(w io.Writer) {
13257         {
13258                 x := (*(*(struct {
13259                         Visible bool
13260                         Texture
13261                         ToneMap Texture
13262                         Size    float32
13263                 }))(obj)).Visible
13264                 if x {
13265                         write8(w, 1)
13266                 } else {
13267                         write8(w, 0)
13268                 }
13269         }
13270         if err := pcall(func() {
13271                 ((*(*(struct {
13272                         Visible bool
13273                         Texture
13274                         ToneMap Texture
13275                         Size    float32
13276                 }))(obj)).Texture).serialize(w)
13277         }); err != nil {
13278                 if err == io.EOF {
13279                         chk(io.EOF)
13280                 }
13281                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13282         }
13283         if err := pcall(func() {
13284                 ((*(*(struct {
13285                         Visible bool
13286                         Texture
13287                         ToneMap Texture
13288                         Size    float32
13289                 }))(obj)).ToneMap).serialize(w)
13290         }); err != nil {
13291                 if err == io.EOF {
13292                         chk(io.EOF)
13293                 }
13294                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13295         }
13296         {
13297                 x := (*(*(struct {
13298                         Visible bool
13299                         Texture
13300                         ToneMap Texture
13301                         Size    float32
13302                 }))(obj)).Size
13303                 write32(w, math.Float32bits(x))
13304         }
13305 }
13306
13307 func (obj *ToCltMoonParams) deserialize(r io.Reader) {
13308         {
13309                 p := &(*(*(struct {
13310                         Visible bool
13311                         Texture
13312                         ToneMap Texture
13313                         Size    float32
13314                 }))(obj)).Visible
13315                 switch n := read8(r); n {
13316                 case 0:
13317                         *p = false
13318                 case 1:
13319                         *p = true
13320                 default:
13321                         chk(fmt.Errorf("invalid bool: %d", n))
13322                 }
13323         }
13324         if err := pcall(func() {
13325                 ((*(*(struct {
13326                         Visible bool
13327                         Texture
13328                         ToneMap Texture
13329                         Size    float32
13330                 }))(obj)).Texture).deserialize(r)
13331         }); err != nil {
13332                 if err == io.EOF {
13333                         chk(io.EOF)
13334                 }
13335                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13336         }
13337         if err := pcall(func() {
13338                 ((*(*(struct {
13339                         Visible bool
13340                         Texture
13341                         ToneMap Texture
13342                         Size    float32
13343                 }))(obj)).ToneMap).deserialize(r)
13344         }); err != nil {
13345                 if err == io.EOF {
13346                         chk(io.EOF)
13347                 }
13348                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13349         }
13350         {
13351                 p := &(*(*(struct {
13352                         Visible bool
13353                         Texture
13354                         ToneMap Texture
13355                         Size    float32
13356                 }))(obj)).Size
13357                 *p = math.Float32frombits(read32(r))
13358         }
13359 }
13360
13361 func (obj *ToCltStarParams) serialize(w io.Writer) {
13362         {
13363                 x := (*(*(struct {
13364                         Visible bool
13365                         Count   uint32
13366                         Color   color.NRGBA
13367                         Size    float32
13368                 }))(obj)).Visible
13369                 if x {
13370                         write8(w, 1)
13371                 } else {
13372                         write8(w, 0)
13373                 }
13374         }
13375         {
13376                 x := (*(*(struct {
13377                         Visible bool
13378                         Count   uint32
13379                         Color   color.NRGBA
13380                         Size    float32
13381                 }))(obj)).Count
13382                 write32(w, uint32(x))
13383         }
13384         {
13385                 x := (*(*(struct {
13386                         Visible bool
13387                         Count   uint32
13388                         Color   color.NRGBA
13389                         Size    float32
13390                 }))(obj)).Color
13391                 w.Write([]byte{x.A, x.R, x.G, x.B})
13392         }
13393         {
13394                 x := (*(*(struct {
13395                         Visible bool
13396                         Count   uint32
13397                         Color   color.NRGBA
13398                         Size    float32
13399                 }))(obj)).Size
13400                 write32(w, math.Float32bits(x))
13401         }
13402 }
13403
13404 func (obj *ToCltStarParams) deserialize(r io.Reader) {
13405         {
13406                 p := &(*(*(struct {
13407                         Visible bool
13408                         Count   uint32
13409                         Color   color.NRGBA
13410                         Size    float32
13411                 }))(obj)).Visible
13412                 switch n := read8(r); n {
13413                 case 0:
13414                         *p = false
13415                 case 1:
13416                         *p = true
13417                 default:
13418                         chk(fmt.Errorf("invalid bool: %d", n))
13419                 }
13420         }
13421         {
13422                 p := &(*(*(struct {
13423                         Visible bool
13424                         Count   uint32
13425                         Color   color.NRGBA
13426                         Size    float32
13427                 }))(obj)).Count
13428                 *p = read32(r)
13429         }
13430         {
13431                 p := &(*(*(struct {
13432                         Visible bool
13433                         Count   uint32
13434                         Color   color.NRGBA
13435                         Size    float32
13436                 }))(obj)).Color
13437                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
13438         }
13439         {
13440                 p := &(*(*(struct {
13441                         Visible bool
13442                         Count   uint32
13443                         Color   color.NRGBA
13444                         Size    float32
13445                 }))(obj)).Size
13446                 *p = math.Float32frombits(read32(r))
13447         }
13448 }
13449
13450 func (obj *ToCltSRPBytesSaltB) serialize(w io.Writer) {
13451         if len(((*(*(struct {
13452                 Salt, B []byte
13453         }))(obj)).Salt)) > math.MaxUint16 {
13454                 chk(ErrTooLong)
13455         }
13456         {
13457                 x := uint16(len(((*(*(struct {
13458                         Salt, B []byte
13459                 }))(obj)).Salt)))
13460                 write16(w, uint16(x))
13461         }
13462         {
13463                 _, err := w.Write(((*(*(struct {
13464                         Salt, B []byte
13465                 }))(obj)).Salt)[:])
13466                 chk(err)
13467         }
13468         if len(((*(*(struct {
13469                 Salt, B []byte
13470         }))(obj)).B)) > math.MaxUint16 {
13471                 chk(ErrTooLong)
13472         }
13473         {
13474                 x := uint16(len(((*(*(struct {
13475                         Salt, B []byte
13476                 }))(obj)).B)))
13477                 write16(w, uint16(x))
13478         }
13479         {
13480                 _, err := w.Write(((*(*(struct {
13481                         Salt, B []byte
13482                 }))(obj)).B)[:])
13483                 chk(err)
13484         }
13485 }
13486
13487 func (obj *ToCltSRPBytesSaltB) deserialize(r io.Reader) {
13488         var local221 uint16
13489         {
13490                 p := &local221
13491                 *p = read16(r)
13492         }
13493         ((*(*(struct {
13494                 Salt, B []byte
13495         }))(obj)).Salt) = make([]byte, local221)
13496         {
13497                 _, err := io.ReadFull(r, ((*(*(struct {
13498                         Salt, B []byte
13499                 }))(obj)).Salt)[:])
13500                 chk(err)
13501         }
13502         var local222 uint16
13503         {
13504                 p := &local222
13505                 *p = read16(r)
13506         }
13507         ((*(*(struct {
13508                 Salt, B []byte
13509         }))(obj)).B) = make([]byte, local222)
13510         {
13511                 _, err := io.ReadFull(r, ((*(*(struct {
13512                         Salt, B []byte
13513                 }))(obj)).B)[:])
13514                 chk(err)
13515         }
13516 }
13517
13518 func (obj *ToCltFormspecPrepend) serialize(w io.Writer) {
13519         if len(([]byte((*(*(struct {
13520                 Prepend string
13521         }))(obj)).Prepend))) > math.MaxUint16 {
13522                 chk(ErrTooLong)
13523         }
13524         {
13525                 x := uint16(len(([]byte((*(*(struct {
13526                         Prepend string
13527                 }))(obj)).Prepend))))
13528                 write16(w, uint16(x))
13529         }
13530         {
13531                 _, err := w.Write(([]byte((*(*(struct {
13532                         Prepend string
13533                 }))(obj)).Prepend))[:])
13534                 chk(err)
13535         }
13536 }
13537
13538 func (obj *ToCltFormspecPrepend) deserialize(r io.Reader) {
13539         var local223 []uint8
13540         var local224 uint16
13541         {
13542                 p := &local224
13543                 *p = read16(r)
13544         }
13545         (local223) = make([]uint8, local224)
13546         {
13547                 _, err := io.ReadFull(r, (local223)[:])
13548                 chk(err)
13549         }
13550         ((*(*(struct {
13551                 Prepend string
13552         }))(obj)).Prepend) = string(local223)
13553 }
13554
13555 func (obj *AOCmdProps) serialize(w io.Writer) {
13556         if err := pcall(func() {
13557                 ((*(*(struct {
13558                         Props AOProps
13559                 }))(obj)).Props).serialize(w)
13560         }); err != nil {
13561                 if err == io.EOF {
13562                         chk(io.EOF)
13563                 }
13564                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOProps", err))
13565         }
13566 }
13567
13568 func (obj *AOCmdProps) deserialize(r io.Reader) {
13569         if err := pcall(func() {
13570                 ((*(*(struct {
13571                         Props AOProps
13572                 }))(obj)).Props).deserialize(r)
13573         }); err != nil {
13574                 if err == io.EOF {
13575                         chk(io.EOF)
13576                 }
13577                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOProps", err))
13578         }
13579 }
13580
13581 func (obj *AOCmdPos) serialize(w io.Writer) {
13582         if err := pcall(func() {
13583                 ((*(*(struct {
13584                         Pos AOPos
13585                 }))(obj)).Pos).serialize(w)
13586         }); err != nil {
13587                 if err == io.EOF {
13588                         chk(io.EOF)
13589                 }
13590                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPos", err))
13591         }
13592 }
13593
13594 func (obj *AOCmdPos) deserialize(r io.Reader) {
13595         if err := pcall(func() {
13596                 ((*(*(struct {
13597                         Pos AOPos
13598                 }))(obj)).Pos).deserialize(r)
13599         }); err != nil {
13600                 if err == io.EOF {
13601                         chk(io.EOF)
13602                 }
13603                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPos", err))
13604         }
13605 }
13606
13607 func (obj *AOCmdTextureMod) serialize(w io.Writer) {
13608         if err := pcall(func() {
13609                 ((*(*(struct {
13610                         Mod Texture // suffix
13611                 }))(obj)).Mod).serialize(w)
13612         }); err != nil {
13613                 if err == io.EOF {
13614                         chk(io.EOF)
13615                 }
13616                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13617         }
13618 }
13619
13620 func (obj *AOCmdTextureMod) deserialize(r io.Reader) {
13621         if err := pcall(func() {
13622                 ((*(*(struct {
13623                         Mod Texture // suffix
13624                 }))(obj)).Mod).deserialize(r)
13625         }); err != nil {
13626                 if err == io.EOF {
13627                         chk(io.EOF)
13628                 }
13629                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
13630         }
13631 }
13632
13633 func (obj *AOCmdSprite) serialize(w io.Writer) {
13634         if err := pcall(func() {
13635                 ((*(*(struct {
13636                         Sprite AOSprite
13637                 }))(obj)).Sprite).serialize(w)
13638         }); err != nil {
13639                 if err == io.EOF {
13640                         chk(io.EOF)
13641                 }
13642                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOSprite", err))
13643         }
13644 }
13645
13646 func (obj *AOCmdSprite) deserialize(r io.Reader) {
13647         if err := pcall(func() {
13648                 ((*(*(struct {
13649                         Sprite AOSprite
13650                 }))(obj)).Sprite).deserialize(r)
13651         }); err != nil {
13652                 if err == io.EOF {
13653                         chk(io.EOF)
13654                 }
13655                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOSprite", err))
13656         }
13657 }
13658
13659 func (obj *AOCmdHP) serialize(w io.Writer) {
13660         {
13661                 x := (*(*(struct {
13662                         HP uint16
13663                 }))(obj)).HP
13664                 write16(w, uint16(x))
13665         }
13666 }
13667
13668 func (obj *AOCmdHP) deserialize(r io.Reader) {
13669         {
13670                 p := &(*(*(struct {
13671                         HP uint16
13672                 }))(obj)).HP
13673                 *p = read16(r)
13674         }
13675 }
13676
13677 func (obj *AOCmdArmorGroups) serialize(w io.Writer) {
13678         if len(((*(*(struct {
13679                 Armor []Group
13680         }))(obj)).Armor)) > math.MaxUint16 {
13681                 chk(ErrTooLong)
13682         }
13683         {
13684                 x := uint16(len(((*(*(struct {
13685                         Armor []Group
13686                 }))(obj)).Armor)))
13687                 write16(w, uint16(x))
13688         }
13689         for local225 := range (*(*(struct {
13690                 Armor []Group
13691         }))(obj)).Armor {
13692                 if err := pcall(func() {
13693                         (((*(*(struct {
13694                                 Armor []Group
13695                         }))(obj)).Armor)[local225]).serialize(w)
13696                 }); err != nil {
13697                         if err == io.EOF {
13698                                 chk(io.EOF)
13699                         }
13700                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
13701                 }
13702         }
13703 }
13704
13705 func (obj *AOCmdArmorGroups) deserialize(r io.Reader) {
13706         var local226 uint16
13707         {
13708                 p := &local226
13709                 *p = read16(r)
13710         }
13711         ((*(*(struct {
13712                 Armor []Group
13713         }))(obj)).Armor) = make([]Group, local226)
13714         for local227 := range (*(*(struct {
13715                 Armor []Group
13716         }))(obj)).Armor {
13717                 if err := pcall(func() {
13718                         (((*(*(struct {
13719                                 Armor []Group
13720                         }))(obj)).Armor)[local227]).deserialize(r)
13721                 }); err != nil {
13722                         if err == io.EOF {
13723                                 chk(io.EOF)
13724                         }
13725                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
13726                 }
13727         }
13728 }
13729
13730 func (obj *AOCmdAnim) serialize(w io.Writer) {
13731         if err := pcall(func() {
13732                 ((*(*(struct {
13733                         Anim AOAnim
13734                 }))(obj)).Anim).serialize(w)
13735         }); err != nil {
13736                 if err == io.EOF {
13737                         chk(io.EOF)
13738                 }
13739                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAnim", err))
13740         }
13741 }
13742
13743 func (obj *AOCmdAnim) deserialize(r io.Reader) {
13744         if err := pcall(func() {
13745                 ((*(*(struct {
13746                         Anim AOAnim
13747                 }))(obj)).Anim).deserialize(r)
13748         }); err != nil {
13749                 if err == io.EOF {
13750                         chk(io.EOF)
13751                 }
13752                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAnim", err))
13753         }
13754 }
13755
13756 func (obj *AOCmdBonePos) serialize(w io.Writer) {
13757         if len(([]byte((*(*(struct {
13758                 Bone string
13759                 Pos  AOBonePos
13760         }))(obj)).Bone))) > math.MaxUint16 {
13761                 chk(ErrTooLong)
13762         }
13763         {
13764                 x := uint16(len(([]byte((*(*(struct {
13765                         Bone string
13766                         Pos  AOBonePos
13767                 }))(obj)).Bone))))
13768                 write16(w, uint16(x))
13769         }
13770         {
13771                 _, err := w.Write(([]byte((*(*(struct {
13772                         Bone string
13773                         Pos  AOBonePos
13774                 }))(obj)).Bone))[:])
13775                 chk(err)
13776         }
13777         if err := pcall(func() {
13778                 ((*(*(struct {
13779                         Bone string
13780                         Pos  AOBonePos
13781                 }))(obj)).Pos).serialize(w)
13782         }); err != nil {
13783                 if err == io.EOF {
13784                         chk(io.EOF)
13785                 }
13786                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOBonePos", err))
13787         }
13788 }
13789
13790 func (obj *AOCmdBonePos) deserialize(r io.Reader) {
13791         var local228 []uint8
13792         var local229 uint16
13793         {
13794                 p := &local229
13795                 *p = read16(r)
13796         }
13797         (local228) = make([]uint8, local229)
13798         {
13799                 _, err := io.ReadFull(r, (local228)[:])
13800                 chk(err)
13801         }
13802         ((*(*(struct {
13803                 Bone string
13804                 Pos  AOBonePos
13805         }))(obj)).Bone) = string(local228)
13806         if err := pcall(func() {
13807                 ((*(*(struct {
13808                         Bone string
13809                         Pos  AOBonePos
13810                 }))(obj)).Pos).deserialize(r)
13811         }); err != nil {
13812                 if err == io.EOF {
13813                         chk(io.EOF)
13814                 }
13815                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOBonePos", err))
13816         }
13817 }
13818
13819 func (obj *AOCmdAttach) serialize(w io.Writer) {
13820         if err := pcall(func() {
13821                 ((*(*(struct {
13822                         Attach AOAttach
13823                 }))(obj)).Attach).serialize(w)
13824         }); err != nil {
13825                 if err == io.EOF {
13826                         chk(io.EOF)
13827                 }
13828                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAttach", err))
13829         }
13830 }
13831
13832 func (obj *AOCmdAttach) deserialize(r io.Reader) {
13833         if err := pcall(func() {
13834                 ((*(*(struct {
13835                         Attach AOAttach
13836                 }))(obj)).Attach).deserialize(r)
13837         }); err != nil {
13838                 if err == io.EOF {
13839                         chk(io.EOF)
13840                 }
13841                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOAttach", err))
13842         }
13843 }
13844
13845 func (obj *AOCmdPhysOverride) serialize(w io.Writer) {
13846         if err := pcall(func() {
13847                 ((*(*(struct {
13848                         Phys AOPhysOverride
13849                 }))(obj)).Phys).serialize(w)
13850         }); err != nil {
13851                 if err == io.EOF {
13852                         chk(io.EOF)
13853                 }
13854                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPhysOverride", err))
13855         }
13856 }
13857
13858 func (obj *AOCmdPhysOverride) deserialize(r io.Reader) {
13859         if err := pcall(func() {
13860                 ((*(*(struct {
13861                         Phys AOPhysOverride
13862                 }))(obj)).Phys).deserialize(r)
13863         }); err != nil {
13864                 if err == io.EOF {
13865                         chk(io.EOF)
13866                 }
13867                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOPhysOverride", err))
13868         }
13869 }
13870
13871 func (obj *AOCmdSpawnInfant) serialize(w io.Writer) {
13872         if err := pcall(func() {
13873                 ((*(*(struct {
13874                         ID AOID
13875                 }))(obj)).ID).serialize(w)
13876         }); err != nil {
13877                 if err == io.EOF {
13878                         chk(io.EOF)
13879                 }
13880                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
13881         }
13882         {
13883                 local230 := genericCAO
13884                 if err := pcall(func() {
13885                         (local230).serialize(w)
13886                 }); err != nil {
13887                         if err == io.EOF {
13888                                 chk(io.EOF)
13889                         }
13890                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
13891                 }
13892         }
13893 }
13894
13895 func (obj *AOCmdSpawnInfant) deserialize(r io.Reader) {
13896         if err := pcall(func() {
13897                 ((*(*(struct {
13898                         ID AOID
13899                 }))(obj)).ID).deserialize(r)
13900         }); err != nil {
13901                 if err == io.EOF {
13902                         chk(io.EOF)
13903                 }
13904                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
13905         }
13906         {
13907                 var local231 aoType
13908                 local232 := genericCAO
13909                 if err := pcall(func() {
13910                         (local231).deserialize(r)
13911                 }); err != nil {
13912                         if err == io.EOF {
13913                                 chk(io.EOF)
13914                         }
13915                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
13916                 }
13917                 if local231 != local232 {
13918                         chk(fmt.Errorf("const %v: %v", "genericCAO", local231))
13919                 }
13920         }
13921 }
13922
13923 func (obj *AOCmdAnimSpeed) serialize(w io.Writer) {
13924         {
13925                 x := (*(*(struct {
13926                         Speed float32
13927                 }))(obj)).Speed
13928                 write32(w, math.Float32bits(x))
13929         }
13930 }
13931
13932 func (obj *AOCmdAnimSpeed) deserialize(r io.Reader) {
13933         {
13934                 p := &(*(*(struct {
13935                         Speed float32
13936                 }))(obj)).Speed
13937                 *p = math.Float32frombits(read32(r))
13938         }
13939 }
13940
13941 func (obj *NodeMeta) serialize(w io.Writer) {
13942         if len(((*(*(struct {
13943                 //mt:len32
13944                 Fields []NodeMetaField
13945
13946                 Inv Inv
13947         }))(obj)).Fields)) > math.MaxUint32 {
13948                 chk(ErrTooLong)
13949         }
13950         {
13951                 x := uint32(len(((*(*(struct {
13952                         //mt:len32
13953                         Fields []NodeMetaField
13954
13955                         Inv Inv
13956                 }))(obj)).Fields)))
13957                 write32(w, uint32(x))
13958         }
13959         for local233 := range (*(*(struct {
13960                 //mt:len32
13961                 Fields []NodeMetaField
13962
13963                 Inv Inv
13964         }))(obj)).Fields {
13965                 if err := pcall(func() {
13966                         (((*(*(struct {
13967                                 //mt:len32
13968                                 Fields []NodeMetaField
13969
13970                                 Inv Inv
13971                         }))(obj)).Fields)[local233]).serialize(w)
13972                 }); err != nil {
13973                         if err == io.EOF {
13974                                 chk(io.EOF)
13975                         }
13976                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeMetaField", err))
13977                 }
13978         }
13979         chk(((*(*(struct {
13980                 //mt:len32
13981                 Fields []NodeMetaField
13982
13983                 Inv Inv
13984         }))(obj)).Inv).Serialize(w))
13985 }
13986
13987 func (obj *NodeMeta) deserialize(r io.Reader) {
13988         var local234 uint32
13989         {
13990                 p := &local234
13991                 *p = read32(r)
13992         }
13993         ((*(*(struct {
13994                 //mt:len32
13995                 Fields []NodeMetaField
13996
13997                 Inv Inv
13998         }))(obj)).Fields) = make([]NodeMetaField, local234)
13999         for local235 := range (*(*(struct {
14000                 //mt:len32
14001                 Fields []NodeMetaField
14002
14003                 Inv Inv
14004         }))(obj)).Fields {
14005                 if err := pcall(func() {
14006                         (((*(*(struct {
14007                                 //mt:len32
14008                                 Fields []NodeMetaField
14009
14010                                 Inv Inv
14011                         }))(obj)).Fields)[local235]).deserialize(r)
14012                 }); err != nil {
14013                         if err == io.EOF {
14014                                 chk(io.EOF)
14015                         }
14016                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeMetaField", err))
14017                 }
14018         }
14019         chk(((*(*(struct {
14020                 //mt:len32
14021                 Fields []NodeMetaField
14022
14023                 Inv Inv
14024         }))(obj)).Inv).Deserialize(r))
14025 }
14026
14027 func (obj *MinimapMode) serialize(w io.Writer) {
14028         if err := pcall(func() {
14029                 ((*(*(struct {
14030                         Type  MinimapType
14031                         Label string
14032                         Size  uint16
14033                         Texture
14034                         Scale uint16
14035                 }))(obj)).Type).serialize(w)
14036         }); err != nil {
14037                 if err == io.EOF {
14038                         chk(io.EOF)
14039                 }
14040                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MinimapType", err))
14041         }
14042         if len(([]byte((*(*(struct {
14043                 Type  MinimapType
14044                 Label string
14045                 Size  uint16
14046                 Texture
14047                 Scale uint16
14048         }))(obj)).Label))) > math.MaxUint16 {
14049                 chk(ErrTooLong)
14050         }
14051         {
14052                 x := uint16(len(([]byte((*(*(struct {
14053                         Type  MinimapType
14054                         Label string
14055                         Size  uint16
14056                         Texture
14057                         Scale uint16
14058                 }))(obj)).Label))))
14059                 write16(w, uint16(x))
14060         }
14061         {
14062                 _, err := w.Write(([]byte((*(*(struct {
14063                         Type  MinimapType
14064                         Label string
14065                         Size  uint16
14066                         Texture
14067                         Scale uint16
14068                 }))(obj)).Label))[:])
14069                 chk(err)
14070         }
14071         {
14072                 x := (*(*(struct {
14073                         Type  MinimapType
14074                         Label string
14075                         Size  uint16
14076                         Texture
14077                         Scale uint16
14078                 }))(obj)).Size
14079                 write16(w, uint16(x))
14080         }
14081         if err := pcall(func() {
14082                 ((*(*(struct {
14083                         Type  MinimapType
14084                         Label string
14085                         Size  uint16
14086                         Texture
14087                         Scale uint16
14088                 }))(obj)).Texture).serialize(w)
14089         }); err != nil {
14090                 if err == io.EOF {
14091                         chk(io.EOF)
14092                 }
14093                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
14094         }
14095         {
14096                 x := (*(*(struct {
14097                         Type  MinimapType
14098                         Label string
14099                         Size  uint16
14100                         Texture
14101                         Scale uint16
14102                 }))(obj)).Scale
14103                 write16(w, uint16(x))
14104         }
14105 }
14106
14107 func (obj *MinimapMode) deserialize(r io.Reader) {
14108         if err := pcall(func() {
14109                 ((*(*(struct {
14110                         Type  MinimapType
14111                         Label string
14112                         Size  uint16
14113                         Texture
14114                         Scale uint16
14115                 }))(obj)).Type).deserialize(r)
14116         }); err != nil {
14117                 if err == io.EOF {
14118                         chk(io.EOF)
14119                 }
14120                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MinimapType", err))
14121         }
14122         var local236 []uint8
14123         var local237 uint16
14124         {
14125                 p := &local237
14126                 *p = read16(r)
14127         }
14128         (local236) = make([]uint8, local237)
14129         {
14130                 _, err := io.ReadFull(r, (local236)[:])
14131                 chk(err)
14132         }
14133         ((*(*(struct {
14134                 Type  MinimapType
14135                 Label string
14136                 Size  uint16
14137                 Texture
14138                 Scale uint16
14139         }))(obj)).Label) = string(local236)
14140         {
14141                 p := &(*(*(struct {
14142                         Type  MinimapType
14143                         Label string
14144                         Size  uint16
14145                         Texture
14146                         Scale uint16
14147                 }))(obj)).Size
14148                 *p = read16(r)
14149         }
14150         if err := pcall(func() {
14151                 ((*(*(struct {
14152                         Type  MinimapType
14153                         Label string
14154                         Size  uint16
14155                         Texture
14156                         Scale uint16
14157                 }))(obj)).Texture).deserialize(r)
14158         }); err != nil {
14159                 if err == io.EOF {
14160                         chk(io.EOF)
14161                 }
14162                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
14163         }
14164         {
14165                 p := &(*(*(struct {
14166                         Type  MinimapType
14167                         Label string
14168                         Size  uint16
14169                         Texture
14170                         Scale uint16
14171                 }))(obj)).Scale
14172                 *p = read16(r)
14173         }
14174 }
14175
14176 func (obj *NodeDef) serialize(w io.Writer) {
14177         if err := pcall(func() {
14178                 ((*(*(struct {
14179                         Param0 Content
14180
14181                         Name   string
14182                         Groups []Group
14183
14184                         P1Type   Param1Type
14185                         P2Type   Param2Type
14186                         DrawType DrawType
14187
14188                         Mesh  string
14189                         Scale float32
14190                         //mt:const uint8(6)
14191                         Tiles        [6]TileDef
14192                         OverlayTiles [6]TileDef
14193                         //mt:const uint8(6)
14194                         SpecialTiles [6]TileDef
14195
14196                         Color   color.NRGBA
14197                         Palette Texture
14198
14199                         Waving       WaveType
14200                         ConnectSides uint8
14201                         ConnectTo    []Content
14202                         InsideTint   color.NRGBA
14203                         Level        uint8 // Must be < 128.
14204
14205                         Translucent bool // Sunlight is scattered and becomes normal light.
14206                         Transparent bool // Sunlight isn't scattered.
14207                         LightSrc    uint8
14208
14209                         GndContent   bool
14210                         Collides     bool
14211                         Pointable    bool
14212                         Diggable     bool
14213                         Climbable    bool
14214                         Replaceable  bool
14215                         OnRightClick bool
14216
14217                         DmgPerSec int32
14218
14219                         LiquidType   LiquidType
14220                         FlowingAlt   string
14221                         SrcAlt       string
14222                         Viscosity    uint8 // 0-7
14223                         LiqRenewable bool
14224                         FlowRange    uint8
14225                         DrownDmg     uint8
14226                         Floodable    bool
14227
14228                         DrawBox, ColBox, SelBox NodeBox
14229
14230                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14231
14232                         LegacyFaceDir bool
14233                         LegacyMounted bool
14234
14235                         DigPredict string
14236
14237                         MaxLvl uint8
14238
14239                         AlphaUse
14240
14241                         MoveResistance uint8
14242
14243                         LiquidMovePhysics bool
14244                 }))(obj)).Param0).serialize(w)
14245         }); err != nil {
14246                 if err == io.EOF {
14247                         chk(io.EOF)
14248                 }
14249                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
14250         }
14251         {
14252                 ow := w
14253                 w := new(bytes.Buffer)
14254                 {
14255                         local238 := uint8(13)
14256                         {
14257                                 x := local238
14258                                 write8(w, uint8(x))
14259                         }
14260                 }
14261                 if len(([]byte((*(*(struct {
14262                         Param0 Content
14263
14264                         Name   string
14265                         Groups []Group
14266
14267                         P1Type   Param1Type
14268                         P2Type   Param2Type
14269                         DrawType DrawType
14270
14271                         Mesh  string
14272                         Scale float32
14273                         //mt:const uint8(6)
14274                         Tiles        [6]TileDef
14275                         OverlayTiles [6]TileDef
14276                         //mt:const uint8(6)
14277                         SpecialTiles [6]TileDef
14278
14279                         Color   color.NRGBA
14280                         Palette Texture
14281
14282                         Waving       WaveType
14283                         ConnectSides uint8
14284                         ConnectTo    []Content
14285                         InsideTint   color.NRGBA
14286                         Level        uint8 // Must be < 128.
14287
14288                         Translucent bool // Sunlight is scattered and becomes normal light.
14289                         Transparent bool // Sunlight isn't scattered.
14290                         LightSrc    uint8
14291
14292                         GndContent   bool
14293                         Collides     bool
14294                         Pointable    bool
14295                         Diggable     bool
14296                         Climbable    bool
14297                         Replaceable  bool
14298                         OnRightClick bool
14299
14300                         DmgPerSec int32
14301
14302                         LiquidType   LiquidType
14303                         FlowingAlt   string
14304                         SrcAlt       string
14305                         Viscosity    uint8 // 0-7
14306                         LiqRenewable bool
14307                         FlowRange    uint8
14308                         DrownDmg     uint8
14309                         Floodable    bool
14310
14311                         DrawBox, ColBox, SelBox NodeBox
14312
14313                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14314
14315                         LegacyFaceDir bool
14316                         LegacyMounted bool
14317
14318                         DigPredict string
14319
14320                         MaxLvl uint8
14321
14322                         AlphaUse
14323
14324                         MoveResistance uint8
14325
14326                         LiquidMovePhysics bool
14327                 }))(obj)).Name))) > math.MaxUint16 {
14328                         chk(ErrTooLong)
14329                 }
14330                 {
14331                         x := uint16(len(([]byte((*(*(struct {
14332                                 Param0 Content
14333
14334                                 Name   string
14335                                 Groups []Group
14336
14337                                 P1Type   Param1Type
14338                                 P2Type   Param2Type
14339                                 DrawType DrawType
14340
14341                                 Mesh  string
14342                                 Scale float32
14343                                 //mt:const uint8(6)
14344                                 Tiles        [6]TileDef
14345                                 OverlayTiles [6]TileDef
14346                                 //mt:const uint8(6)
14347                                 SpecialTiles [6]TileDef
14348
14349                                 Color   color.NRGBA
14350                                 Palette Texture
14351
14352                                 Waving       WaveType
14353                                 ConnectSides uint8
14354                                 ConnectTo    []Content
14355                                 InsideTint   color.NRGBA
14356                                 Level        uint8 // Must be < 128.
14357
14358                                 Translucent bool // Sunlight is scattered and becomes normal light.
14359                                 Transparent bool // Sunlight isn't scattered.
14360                                 LightSrc    uint8
14361
14362                                 GndContent   bool
14363                                 Collides     bool
14364                                 Pointable    bool
14365                                 Diggable     bool
14366                                 Climbable    bool
14367                                 Replaceable  bool
14368                                 OnRightClick bool
14369
14370                                 DmgPerSec int32
14371
14372                                 LiquidType   LiquidType
14373                                 FlowingAlt   string
14374                                 SrcAlt       string
14375                                 Viscosity    uint8 // 0-7
14376                                 LiqRenewable bool
14377                                 FlowRange    uint8
14378                                 DrownDmg     uint8
14379                                 Floodable    bool
14380
14381                                 DrawBox, ColBox, SelBox NodeBox
14382
14383                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14384
14385                                 LegacyFaceDir bool
14386                                 LegacyMounted bool
14387
14388                                 DigPredict string
14389
14390                                 MaxLvl uint8
14391
14392                                 AlphaUse
14393
14394                                 MoveResistance uint8
14395
14396                                 LiquidMovePhysics bool
14397                         }))(obj)).Name))))
14398                         write16(w, uint16(x))
14399                 }
14400                 {
14401                         _, err := w.Write(([]byte((*(*(struct {
14402                                 Param0 Content
14403
14404                                 Name   string
14405                                 Groups []Group
14406
14407                                 P1Type   Param1Type
14408                                 P2Type   Param2Type
14409                                 DrawType DrawType
14410
14411                                 Mesh  string
14412                                 Scale float32
14413                                 //mt:const uint8(6)
14414                                 Tiles        [6]TileDef
14415                                 OverlayTiles [6]TileDef
14416                                 //mt:const uint8(6)
14417                                 SpecialTiles [6]TileDef
14418
14419                                 Color   color.NRGBA
14420                                 Palette Texture
14421
14422                                 Waving       WaveType
14423                                 ConnectSides uint8
14424                                 ConnectTo    []Content
14425                                 InsideTint   color.NRGBA
14426                                 Level        uint8 // Must be < 128.
14427
14428                                 Translucent bool // Sunlight is scattered and becomes normal light.
14429                                 Transparent bool // Sunlight isn't scattered.
14430                                 LightSrc    uint8
14431
14432                                 GndContent   bool
14433                                 Collides     bool
14434                                 Pointable    bool
14435                                 Diggable     bool
14436                                 Climbable    bool
14437                                 Replaceable  bool
14438                                 OnRightClick bool
14439
14440                                 DmgPerSec int32
14441
14442                                 LiquidType   LiquidType
14443                                 FlowingAlt   string
14444                                 SrcAlt       string
14445                                 Viscosity    uint8 // 0-7
14446                                 LiqRenewable bool
14447                                 FlowRange    uint8
14448                                 DrownDmg     uint8
14449                                 Floodable    bool
14450
14451                                 DrawBox, ColBox, SelBox NodeBox
14452
14453                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14454
14455                                 LegacyFaceDir bool
14456                                 LegacyMounted bool
14457
14458                                 DigPredict string
14459
14460                                 MaxLvl uint8
14461
14462                                 AlphaUse
14463
14464                                 MoveResistance uint8
14465
14466                                 LiquidMovePhysics bool
14467                         }))(obj)).Name))[:])
14468                         chk(err)
14469                 }
14470                 if len(((*(*(struct {
14471                         Param0 Content
14472
14473                         Name   string
14474                         Groups []Group
14475
14476                         P1Type   Param1Type
14477                         P2Type   Param2Type
14478                         DrawType DrawType
14479
14480                         Mesh  string
14481                         Scale float32
14482                         //mt:const uint8(6)
14483                         Tiles        [6]TileDef
14484                         OverlayTiles [6]TileDef
14485                         //mt:const uint8(6)
14486                         SpecialTiles [6]TileDef
14487
14488                         Color   color.NRGBA
14489                         Palette Texture
14490
14491                         Waving       WaveType
14492                         ConnectSides uint8
14493                         ConnectTo    []Content
14494                         InsideTint   color.NRGBA
14495                         Level        uint8 // Must be < 128.
14496
14497                         Translucent bool // Sunlight is scattered and becomes normal light.
14498                         Transparent bool // Sunlight isn't scattered.
14499                         LightSrc    uint8
14500
14501                         GndContent   bool
14502                         Collides     bool
14503                         Pointable    bool
14504                         Diggable     bool
14505                         Climbable    bool
14506                         Replaceable  bool
14507                         OnRightClick bool
14508
14509                         DmgPerSec int32
14510
14511                         LiquidType   LiquidType
14512                         FlowingAlt   string
14513                         SrcAlt       string
14514                         Viscosity    uint8 // 0-7
14515                         LiqRenewable bool
14516                         FlowRange    uint8
14517                         DrownDmg     uint8
14518                         Floodable    bool
14519
14520                         DrawBox, ColBox, SelBox NodeBox
14521
14522                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14523
14524                         LegacyFaceDir bool
14525                         LegacyMounted bool
14526
14527                         DigPredict string
14528
14529                         MaxLvl uint8
14530
14531                         AlphaUse
14532
14533                         MoveResistance uint8
14534
14535                         LiquidMovePhysics bool
14536                 }))(obj)).Groups)) > math.MaxUint16 {
14537                         chk(ErrTooLong)
14538                 }
14539                 {
14540                         x := uint16(len(((*(*(struct {
14541                                 Param0 Content
14542
14543                                 Name   string
14544                                 Groups []Group
14545
14546                                 P1Type   Param1Type
14547                                 P2Type   Param2Type
14548                                 DrawType DrawType
14549
14550                                 Mesh  string
14551                                 Scale float32
14552                                 //mt:const uint8(6)
14553                                 Tiles        [6]TileDef
14554                                 OverlayTiles [6]TileDef
14555                                 //mt:const uint8(6)
14556                                 SpecialTiles [6]TileDef
14557
14558                                 Color   color.NRGBA
14559                                 Palette Texture
14560
14561                                 Waving       WaveType
14562                                 ConnectSides uint8
14563                                 ConnectTo    []Content
14564                                 InsideTint   color.NRGBA
14565                                 Level        uint8 // Must be < 128.
14566
14567                                 Translucent bool // Sunlight is scattered and becomes normal light.
14568                                 Transparent bool // Sunlight isn't scattered.
14569                                 LightSrc    uint8
14570
14571                                 GndContent   bool
14572                                 Collides     bool
14573                                 Pointable    bool
14574                                 Diggable     bool
14575                                 Climbable    bool
14576                                 Replaceable  bool
14577                                 OnRightClick bool
14578
14579                                 DmgPerSec int32
14580
14581                                 LiquidType   LiquidType
14582                                 FlowingAlt   string
14583                                 SrcAlt       string
14584                                 Viscosity    uint8 // 0-7
14585                                 LiqRenewable bool
14586                                 FlowRange    uint8
14587                                 DrownDmg     uint8
14588                                 Floodable    bool
14589
14590                                 DrawBox, ColBox, SelBox NodeBox
14591
14592                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14593
14594                                 LegacyFaceDir bool
14595                                 LegacyMounted bool
14596
14597                                 DigPredict string
14598
14599                                 MaxLvl uint8
14600
14601                                 AlphaUse
14602
14603                                 MoveResistance uint8
14604
14605                                 LiquidMovePhysics bool
14606                         }))(obj)).Groups)))
14607                         write16(w, uint16(x))
14608                 }
14609                 for local239 := range (*(*(struct {
14610                         Param0 Content
14611
14612                         Name   string
14613                         Groups []Group
14614
14615                         P1Type   Param1Type
14616                         P2Type   Param2Type
14617                         DrawType DrawType
14618
14619                         Mesh  string
14620                         Scale float32
14621                         //mt:const uint8(6)
14622                         Tiles        [6]TileDef
14623                         OverlayTiles [6]TileDef
14624                         //mt:const uint8(6)
14625                         SpecialTiles [6]TileDef
14626
14627                         Color   color.NRGBA
14628                         Palette Texture
14629
14630                         Waving       WaveType
14631                         ConnectSides uint8
14632                         ConnectTo    []Content
14633                         InsideTint   color.NRGBA
14634                         Level        uint8 // Must be < 128.
14635
14636                         Translucent bool // Sunlight is scattered and becomes normal light.
14637                         Transparent bool // Sunlight isn't scattered.
14638                         LightSrc    uint8
14639
14640                         GndContent   bool
14641                         Collides     bool
14642                         Pointable    bool
14643                         Diggable     bool
14644                         Climbable    bool
14645                         Replaceable  bool
14646                         OnRightClick bool
14647
14648                         DmgPerSec int32
14649
14650                         LiquidType   LiquidType
14651                         FlowingAlt   string
14652                         SrcAlt       string
14653                         Viscosity    uint8 // 0-7
14654                         LiqRenewable bool
14655                         FlowRange    uint8
14656                         DrownDmg     uint8
14657                         Floodable    bool
14658
14659                         DrawBox, ColBox, SelBox NodeBox
14660
14661                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14662
14663                         LegacyFaceDir bool
14664                         LegacyMounted bool
14665
14666                         DigPredict string
14667
14668                         MaxLvl uint8
14669
14670                         AlphaUse
14671
14672                         MoveResistance uint8
14673
14674                         LiquidMovePhysics bool
14675                 }))(obj)).Groups {
14676                         if err := pcall(func() {
14677                                 (((*(*(struct {
14678                                         Param0 Content
14679
14680                                         Name   string
14681                                         Groups []Group
14682
14683                                         P1Type   Param1Type
14684                                         P2Type   Param2Type
14685                                         DrawType DrawType
14686
14687                                         Mesh  string
14688                                         Scale float32
14689                                         //mt:const uint8(6)
14690                                         Tiles        [6]TileDef
14691                                         OverlayTiles [6]TileDef
14692                                         //mt:const uint8(6)
14693                                         SpecialTiles [6]TileDef
14694
14695                                         Color   color.NRGBA
14696                                         Palette Texture
14697
14698                                         Waving       WaveType
14699                                         ConnectSides uint8
14700                                         ConnectTo    []Content
14701                                         InsideTint   color.NRGBA
14702                                         Level        uint8 // Must be < 128.
14703
14704                                         Translucent bool // Sunlight is scattered and becomes normal light.
14705                                         Transparent bool // Sunlight isn't scattered.
14706                                         LightSrc    uint8
14707
14708                                         GndContent   bool
14709                                         Collides     bool
14710                                         Pointable    bool
14711                                         Diggable     bool
14712                                         Climbable    bool
14713                                         Replaceable  bool
14714                                         OnRightClick bool
14715
14716                                         DmgPerSec int32
14717
14718                                         LiquidType   LiquidType
14719                                         FlowingAlt   string
14720                                         SrcAlt       string
14721                                         Viscosity    uint8 // 0-7
14722                                         LiqRenewable bool
14723                                         FlowRange    uint8
14724                                         DrownDmg     uint8
14725                                         Floodable    bool
14726
14727                                         DrawBox, ColBox, SelBox NodeBox
14728
14729                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
14730
14731                                         LegacyFaceDir bool
14732                                         LegacyMounted bool
14733
14734                                         DigPredict string
14735
14736                                         MaxLvl uint8
14737
14738                                         AlphaUse
14739
14740                                         MoveResistance uint8
14741
14742                                         LiquidMovePhysics bool
14743                                 }))(obj)).Groups)[local239]).serialize(w)
14744                         }); err != nil {
14745                                 if err == io.EOF {
14746                                         chk(io.EOF)
14747                                 }
14748                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
14749                         }
14750                 }
14751                 if err := pcall(func() {
14752                         ((*(*(struct {
14753                                 Param0 Content
14754
14755                                 Name   string
14756                                 Groups []Group
14757
14758                                 P1Type   Param1Type
14759                                 P2Type   Param2Type
14760                                 DrawType DrawType
14761
14762                                 Mesh  string
14763                                 Scale float32
14764                                 //mt:const uint8(6)
14765                                 Tiles        [6]TileDef
14766                                 OverlayTiles [6]TileDef
14767                                 //mt:const uint8(6)
14768                                 SpecialTiles [6]TileDef
14769
14770                                 Color   color.NRGBA
14771                                 Palette Texture
14772
14773                                 Waving       WaveType
14774                                 ConnectSides uint8
14775                                 ConnectTo    []Content
14776                                 InsideTint   color.NRGBA
14777                                 Level        uint8 // Must be < 128.
14778
14779                                 Translucent bool // Sunlight is scattered and becomes normal light.
14780                                 Transparent bool // Sunlight isn't scattered.
14781                                 LightSrc    uint8
14782
14783                                 GndContent   bool
14784                                 Collides     bool
14785                                 Pointable    bool
14786                                 Diggable     bool
14787                                 Climbable    bool
14788                                 Replaceable  bool
14789                                 OnRightClick bool
14790
14791                                 DmgPerSec int32
14792
14793                                 LiquidType   LiquidType
14794                                 FlowingAlt   string
14795                                 SrcAlt       string
14796                                 Viscosity    uint8 // 0-7
14797                                 LiqRenewable bool
14798                                 FlowRange    uint8
14799                                 DrownDmg     uint8
14800                                 Floodable    bool
14801
14802                                 DrawBox, ColBox, SelBox NodeBox
14803
14804                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14805
14806                                 LegacyFaceDir bool
14807                                 LegacyMounted bool
14808
14809                                 DigPredict string
14810
14811                                 MaxLvl uint8
14812
14813                                 AlphaUse
14814
14815                                 MoveResistance uint8
14816
14817                                 LiquidMovePhysics bool
14818                         }))(obj)).P1Type).serialize(w)
14819                 }); err != nil {
14820                         if err == io.EOF {
14821                                 chk(io.EOF)
14822                         }
14823                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param1Type", err))
14824                 }
14825                 if err := pcall(func() {
14826                         ((*(*(struct {
14827                                 Param0 Content
14828
14829                                 Name   string
14830                                 Groups []Group
14831
14832                                 P1Type   Param1Type
14833                                 P2Type   Param2Type
14834                                 DrawType DrawType
14835
14836                                 Mesh  string
14837                                 Scale float32
14838                                 //mt:const uint8(6)
14839                                 Tiles        [6]TileDef
14840                                 OverlayTiles [6]TileDef
14841                                 //mt:const uint8(6)
14842                                 SpecialTiles [6]TileDef
14843
14844                                 Color   color.NRGBA
14845                                 Palette Texture
14846
14847                                 Waving       WaveType
14848                                 ConnectSides uint8
14849                                 ConnectTo    []Content
14850                                 InsideTint   color.NRGBA
14851                                 Level        uint8 // Must be < 128.
14852
14853                                 Translucent bool // Sunlight is scattered and becomes normal light.
14854                                 Transparent bool // Sunlight isn't scattered.
14855                                 LightSrc    uint8
14856
14857                                 GndContent   bool
14858                                 Collides     bool
14859                                 Pointable    bool
14860                                 Diggable     bool
14861                                 Climbable    bool
14862                                 Replaceable  bool
14863                                 OnRightClick bool
14864
14865                                 DmgPerSec int32
14866
14867                                 LiquidType   LiquidType
14868                                 FlowingAlt   string
14869                                 SrcAlt       string
14870                                 Viscosity    uint8 // 0-7
14871                                 LiqRenewable bool
14872                                 FlowRange    uint8
14873                                 DrownDmg     uint8
14874                                 Floodable    bool
14875
14876                                 DrawBox, ColBox, SelBox NodeBox
14877
14878                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14879
14880                                 LegacyFaceDir bool
14881                                 LegacyMounted bool
14882
14883                                 DigPredict string
14884
14885                                 MaxLvl uint8
14886
14887                                 AlphaUse
14888
14889                                 MoveResistance uint8
14890
14891                                 LiquidMovePhysics bool
14892                         }))(obj)).P2Type).serialize(w)
14893                 }); err != nil {
14894                         if err == io.EOF {
14895                                 chk(io.EOF)
14896                         }
14897                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param2Type", err))
14898                 }
14899                 if err := pcall(func() {
14900                         ((*(*(struct {
14901                                 Param0 Content
14902
14903                                 Name   string
14904                                 Groups []Group
14905
14906                                 P1Type   Param1Type
14907                                 P2Type   Param2Type
14908                                 DrawType DrawType
14909
14910                                 Mesh  string
14911                                 Scale float32
14912                                 //mt:const uint8(6)
14913                                 Tiles        [6]TileDef
14914                                 OverlayTiles [6]TileDef
14915                                 //mt:const uint8(6)
14916                                 SpecialTiles [6]TileDef
14917
14918                                 Color   color.NRGBA
14919                                 Palette Texture
14920
14921                                 Waving       WaveType
14922                                 ConnectSides uint8
14923                                 ConnectTo    []Content
14924                                 InsideTint   color.NRGBA
14925                                 Level        uint8 // Must be < 128.
14926
14927                                 Translucent bool // Sunlight is scattered and becomes normal light.
14928                                 Transparent bool // Sunlight isn't scattered.
14929                                 LightSrc    uint8
14930
14931                                 GndContent   bool
14932                                 Collides     bool
14933                                 Pointable    bool
14934                                 Diggable     bool
14935                                 Climbable    bool
14936                                 Replaceable  bool
14937                                 OnRightClick bool
14938
14939                                 DmgPerSec int32
14940
14941                                 LiquidType   LiquidType
14942                                 FlowingAlt   string
14943                                 SrcAlt       string
14944                                 Viscosity    uint8 // 0-7
14945                                 LiqRenewable bool
14946                                 FlowRange    uint8
14947                                 DrownDmg     uint8
14948                                 Floodable    bool
14949
14950                                 DrawBox, ColBox, SelBox NodeBox
14951
14952                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
14953
14954                                 LegacyFaceDir bool
14955                                 LegacyMounted bool
14956
14957                                 DigPredict string
14958
14959                                 MaxLvl uint8
14960
14961                                 AlphaUse
14962
14963                                 MoveResistance uint8
14964
14965                                 LiquidMovePhysics bool
14966                         }))(obj)).DrawType).serialize(w)
14967                 }); err != nil {
14968                         if err == io.EOF {
14969                                 chk(io.EOF)
14970                         }
14971                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DrawType", err))
14972                 }
14973                 if len(([]byte((*(*(struct {
14974                         Param0 Content
14975
14976                         Name   string
14977                         Groups []Group
14978
14979                         P1Type   Param1Type
14980                         P2Type   Param2Type
14981                         DrawType DrawType
14982
14983                         Mesh  string
14984                         Scale float32
14985                         //mt:const uint8(6)
14986                         Tiles        [6]TileDef
14987                         OverlayTiles [6]TileDef
14988                         //mt:const uint8(6)
14989                         SpecialTiles [6]TileDef
14990
14991                         Color   color.NRGBA
14992                         Palette Texture
14993
14994                         Waving       WaveType
14995                         ConnectSides uint8
14996                         ConnectTo    []Content
14997                         InsideTint   color.NRGBA
14998                         Level        uint8 // Must be < 128.
14999
15000                         Translucent bool // Sunlight is scattered and becomes normal light.
15001                         Transparent bool // Sunlight isn't scattered.
15002                         LightSrc    uint8
15003
15004                         GndContent   bool
15005                         Collides     bool
15006                         Pointable    bool
15007                         Diggable     bool
15008                         Climbable    bool
15009                         Replaceable  bool
15010                         OnRightClick bool
15011
15012                         DmgPerSec int32
15013
15014                         LiquidType   LiquidType
15015                         FlowingAlt   string
15016                         SrcAlt       string
15017                         Viscosity    uint8 // 0-7
15018                         LiqRenewable bool
15019                         FlowRange    uint8
15020                         DrownDmg     uint8
15021                         Floodable    bool
15022
15023                         DrawBox, ColBox, SelBox NodeBox
15024
15025                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15026
15027                         LegacyFaceDir bool
15028                         LegacyMounted bool
15029
15030                         DigPredict string
15031
15032                         MaxLvl uint8
15033
15034                         AlphaUse
15035
15036                         MoveResistance uint8
15037
15038                         LiquidMovePhysics bool
15039                 }))(obj)).Mesh))) > math.MaxUint16 {
15040                         chk(ErrTooLong)
15041                 }
15042                 {
15043                         x := uint16(len(([]byte((*(*(struct {
15044                                 Param0 Content
15045
15046                                 Name   string
15047                                 Groups []Group
15048
15049                                 P1Type   Param1Type
15050                                 P2Type   Param2Type
15051                                 DrawType DrawType
15052
15053                                 Mesh  string
15054                                 Scale float32
15055                                 //mt:const uint8(6)
15056                                 Tiles        [6]TileDef
15057                                 OverlayTiles [6]TileDef
15058                                 //mt:const uint8(6)
15059                                 SpecialTiles [6]TileDef
15060
15061                                 Color   color.NRGBA
15062                                 Palette Texture
15063
15064                                 Waving       WaveType
15065                                 ConnectSides uint8
15066                                 ConnectTo    []Content
15067                                 InsideTint   color.NRGBA
15068                                 Level        uint8 // Must be < 128.
15069
15070                                 Translucent bool // Sunlight is scattered and becomes normal light.
15071                                 Transparent bool // Sunlight isn't scattered.
15072                                 LightSrc    uint8
15073
15074                                 GndContent   bool
15075                                 Collides     bool
15076                                 Pointable    bool
15077                                 Diggable     bool
15078                                 Climbable    bool
15079                                 Replaceable  bool
15080                                 OnRightClick bool
15081
15082                                 DmgPerSec int32
15083
15084                                 LiquidType   LiquidType
15085                                 FlowingAlt   string
15086                                 SrcAlt       string
15087                                 Viscosity    uint8 // 0-7
15088                                 LiqRenewable bool
15089                                 FlowRange    uint8
15090                                 DrownDmg     uint8
15091                                 Floodable    bool
15092
15093                                 DrawBox, ColBox, SelBox NodeBox
15094
15095                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15096
15097                                 LegacyFaceDir bool
15098                                 LegacyMounted bool
15099
15100                                 DigPredict string
15101
15102                                 MaxLvl uint8
15103
15104                                 AlphaUse
15105
15106                                 MoveResistance uint8
15107
15108                                 LiquidMovePhysics bool
15109                         }))(obj)).Mesh))))
15110                         write16(w, uint16(x))
15111                 }
15112                 {
15113                         _, err := w.Write(([]byte((*(*(struct {
15114                                 Param0 Content
15115
15116                                 Name   string
15117                                 Groups []Group
15118
15119                                 P1Type   Param1Type
15120                                 P2Type   Param2Type
15121                                 DrawType DrawType
15122
15123                                 Mesh  string
15124                                 Scale float32
15125                                 //mt:const uint8(6)
15126                                 Tiles        [6]TileDef
15127                                 OverlayTiles [6]TileDef
15128                                 //mt:const uint8(6)
15129                                 SpecialTiles [6]TileDef
15130
15131                                 Color   color.NRGBA
15132                                 Palette Texture
15133
15134                                 Waving       WaveType
15135                                 ConnectSides uint8
15136                                 ConnectTo    []Content
15137                                 InsideTint   color.NRGBA
15138                                 Level        uint8 // Must be < 128.
15139
15140                                 Translucent bool // Sunlight is scattered and becomes normal light.
15141                                 Transparent bool // Sunlight isn't scattered.
15142                                 LightSrc    uint8
15143
15144                                 GndContent   bool
15145                                 Collides     bool
15146                                 Pointable    bool
15147                                 Diggable     bool
15148                                 Climbable    bool
15149                                 Replaceable  bool
15150                                 OnRightClick bool
15151
15152                                 DmgPerSec int32
15153
15154                                 LiquidType   LiquidType
15155                                 FlowingAlt   string
15156                                 SrcAlt       string
15157                                 Viscosity    uint8 // 0-7
15158                                 LiqRenewable bool
15159                                 FlowRange    uint8
15160                                 DrownDmg     uint8
15161                                 Floodable    bool
15162
15163                                 DrawBox, ColBox, SelBox NodeBox
15164
15165                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15166
15167                                 LegacyFaceDir bool
15168                                 LegacyMounted bool
15169
15170                                 DigPredict string
15171
15172                                 MaxLvl uint8
15173
15174                                 AlphaUse
15175
15176                                 MoveResistance uint8
15177
15178                                 LiquidMovePhysics bool
15179                         }))(obj)).Mesh))[:])
15180                         chk(err)
15181                 }
15182                 {
15183                         x := (*(*(struct {
15184                                 Param0 Content
15185
15186                                 Name   string
15187                                 Groups []Group
15188
15189                                 P1Type   Param1Type
15190                                 P2Type   Param2Type
15191                                 DrawType DrawType
15192
15193                                 Mesh  string
15194                                 Scale float32
15195                                 //mt:const uint8(6)
15196                                 Tiles        [6]TileDef
15197                                 OverlayTiles [6]TileDef
15198                                 //mt:const uint8(6)
15199                                 SpecialTiles [6]TileDef
15200
15201                                 Color   color.NRGBA
15202                                 Palette Texture
15203
15204                                 Waving       WaveType
15205                                 ConnectSides uint8
15206                                 ConnectTo    []Content
15207                                 InsideTint   color.NRGBA
15208                                 Level        uint8 // Must be < 128.
15209
15210                                 Translucent bool // Sunlight is scattered and becomes normal light.
15211                                 Transparent bool // Sunlight isn't scattered.
15212                                 LightSrc    uint8
15213
15214                                 GndContent   bool
15215                                 Collides     bool
15216                                 Pointable    bool
15217                                 Diggable     bool
15218                                 Climbable    bool
15219                                 Replaceable  bool
15220                                 OnRightClick bool
15221
15222                                 DmgPerSec int32
15223
15224                                 LiquidType   LiquidType
15225                                 FlowingAlt   string
15226                                 SrcAlt       string
15227                                 Viscosity    uint8 // 0-7
15228                                 LiqRenewable bool
15229                                 FlowRange    uint8
15230                                 DrownDmg     uint8
15231                                 Floodable    bool
15232
15233                                 DrawBox, ColBox, SelBox NodeBox
15234
15235                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15236
15237                                 LegacyFaceDir bool
15238                                 LegacyMounted bool
15239
15240                                 DigPredict string
15241
15242                                 MaxLvl uint8
15243
15244                                 AlphaUse
15245
15246                                 MoveResistance uint8
15247
15248                                 LiquidMovePhysics bool
15249                         }))(obj)).Scale
15250                         write32(w, math.Float32bits(x))
15251                 }
15252                 {
15253                         local240 := uint8(6)
15254                         {
15255                                 x := local240
15256                                 write8(w, uint8(x))
15257                         }
15258                 }
15259                 for local241 := range (*(*(struct {
15260                         Param0 Content
15261
15262                         Name   string
15263                         Groups []Group
15264
15265                         P1Type   Param1Type
15266                         P2Type   Param2Type
15267                         DrawType DrawType
15268
15269                         Mesh  string
15270                         Scale float32
15271                         //mt:const uint8(6)
15272                         Tiles        [6]TileDef
15273                         OverlayTiles [6]TileDef
15274                         //mt:const uint8(6)
15275                         SpecialTiles [6]TileDef
15276
15277                         Color   color.NRGBA
15278                         Palette Texture
15279
15280                         Waving       WaveType
15281                         ConnectSides uint8
15282                         ConnectTo    []Content
15283                         InsideTint   color.NRGBA
15284                         Level        uint8 // Must be < 128.
15285
15286                         Translucent bool // Sunlight is scattered and becomes normal light.
15287                         Transparent bool // Sunlight isn't scattered.
15288                         LightSrc    uint8
15289
15290                         GndContent   bool
15291                         Collides     bool
15292                         Pointable    bool
15293                         Diggable     bool
15294                         Climbable    bool
15295                         Replaceable  bool
15296                         OnRightClick bool
15297
15298                         DmgPerSec int32
15299
15300                         LiquidType   LiquidType
15301                         FlowingAlt   string
15302                         SrcAlt       string
15303                         Viscosity    uint8 // 0-7
15304                         LiqRenewable bool
15305                         FlowRange    uint8
15306                         DrownDmg     uint8
15307                         Floodable    bool
15308
15309                         DrawBox, ColBox, SelBox NodeBox
15310
15311                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15312
15313                         LegacyFaceDir bool
15314                         LegacyMounted bool
15315
15316                         DigPredict string
15317
15318                         MaxLvl uint8
15319
15320                         AlphaUse
15321
15322                         MoveResistance uint8
15323
15324                         LiquidMovePhysics bool
15325                 }))(obj)).Tiles {
15326                         if err := pcall(func() {
15327                                 (((*(*(struct {
15328                                         Param0 Content
15329
15330                                         Name   string
15331                                         Groups []Group
15332
15333                                         P1Type   Param1Type
15334                                         P2Type   Param2Type
15335                                         DrawType DrawType
15336
15337                                         Mesh  string
15338                                         Scale float32
15339                                         //mt:const uint8(6)
15340                                         Tiles        [6]TileDef
15341                                         OverlayTiles [6]TileDef
15342                                         //mt:const uint8(6)
15343                                         SpecialTiles [6]TileDef
15344
15345                                         Color   color.NRGBA
15346                                         Palette Texture
15347
15348                                         Waving       WaveType
15349                                         ConnectSides uint8
15350                                         ConnectTo    []Content
15351                                         InsideTint   color.NRGBA
15352                                         Level        uint8 // Must be < 128.
15353
15354                                         Translucent bool // Sunlight is scattered and becomes normal light.
15355                                         Transparent bool // Sunlight isn't scattered.
15356                                         LightSrc    uint8
15357
15358                                         GndContent   bool
15359                                         Collides     bool
15360                                         Pointable    bool
15361                                         Diggable     bool
15362                                         Climbable    bool
15363                                         Replaceable  bool
15364                                         OnRightClick bool
15365
15366                                         DmgPerSec int32
15367
15368                                         LiquidType   LiquidType
15369                                         FlowingAlt   string
15370                                         SrcAlt       string
15371                                         Viscosity    uint8 // 0-7
15372                                         LiqRenewable bool
15373                                         FlowRange    uint8
15374                                         DrownDmg     uint8
15375                                         Floodable    bool
15376
15377                                         DrawBox, ColBox, SelBox NodeBox
15378
15379                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15380
15381                                         LegacyFaceDir bool
15382                                         LegacyMounted bool
15383
15384                                         DigPredict string
15385
15386                                         MaxLvl uint8
15387
15388                                         AlphaUse
15389
15390                                         MoveResistance uint8
15391
15392                                         LiquidMovePhysics bool
15393                                 }))(obj)).Tiles)[local241]).serialize(w)
15394                         }); err != nil {
15395                                 if err == io.EOF {
15396                                         chk(io.EOF)
15397                                 }
15398                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15399                         }
15400                 }
15401                 for local242 := range (*(*(struct {
15402                         Param0 Content
15403
15404                         Name   string
15405                         Groups []Group
15406
15407                         P1Type   Param1Type
15408                         P2Type   Param2Type
15409                         DrawType DrawType
15410
15411                         Mesh  string
15412                         Scale float32
15413                         //mt:const uint8(6)
15414                         Tiles        [6]TileDef
15415                         OverlayTiles [6]TileDef
15416                         //mt:const uint8(6)
15417                         SpecialTiles [6]TileDef
15418
15419                         Color   color.NRGBA
15420                         Palette Texture
15421
15422                         Waving       WaveType
15423                         ConnectSides uint8
15424                         ConnectTo    []Content
15425                         InsideTint   color.NRGBA
15426                         Level        uint8 // Must be < 128.
15427
15428                         Translucent bool // Sunlight is scattered and becomes normal light.
15429                         Transparent bool // Sunlight isn't scattered.
15430                         LightSrc    uint8
15431
15432                         GndContent   bool
15433                         Collides     bool
15434                         Pointable    bool
15435                         Diggable     bool
15436                         Climbable    bool
15437                         Replaceable  bool
15438                         OnRightClick bool
15439
15440                         DmgPerSec int32
15441
15442                         LiquidType   LiquidType
15443                         FlowingAlt   string
15444                         SrcAlt       string
15445                         Viscosity    uint8 // 0-7
15446                         LiqRenewable bool
15447                         FlowRange    uint8
15448                         DrownDmg     uint8
15449                         Floodable    bool
15450
15451                         DrawBox, ColBox, SelBox NodeBox
15452
15453                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15454
15455                         LegacyFaceDir bool
15456                         LegacyMounted bool
15457
15458                         DigPredict string
15459
15460                         MaxLvl uint8
15461
15462                         AlphaUse
15463
15464                         MoveResistance uint8
15465
15466                         LiquidMovePhysics bool
15467                 }))(obj)).OverlayTiles {
15468                         if err := pcall(func() {
15469                                 (((*(*(struct {
15470                                         Param0 Content
15471
15472                                         Name   string
15473                                         Groups []Group
15474
15475                                         P1Type   Param1Type
15476                                         P2Type   Param2Type
15477                                         DrawType DrawType
15478
15479                                         Mesh  string
15480                                         Scale float32
15481                                         //mt:const uint8(6)
15482                                         Tiles        [6]TileDef
15483                                         OverlayTiles [6]TileDef
15484                                         //mt:const uint8(6)
15485                                         SpecialTiles [6]TileDef
15486
15487                                         Color   color.NRGBA
15488                                         Palette Texture
15489
15490                                         Waving       WaveType
15491                                         ConnectSides uint8
15492                                         ConnectTo    []Content
15493                                         InsideTint   color.NRGBA
15494                                         Level        uint8 // Must be < 128.
15495
15496                                         Translucent bool // Sunlight is scattered and becomes normal light.
15497                                         Transparent bool // Sunlight isn't scattered.
15498                                         LightSrc    uint8
15499
15500                                         GndContent   bool
15501                                         Collides     bool
15502                                         Pointable    bool
15503                                         Diggable     bool
15504                                         Climbable    bool
15505                                         Replaceable  bool
15506                                         OnRightClick bool
15507
15508                                         DmgPerSec int32
15509
15510                                         LiquidType   LiquidType
15511                                         FlowingAlt   string
15512                                         SrcAlt       string
15513                                         Viscosity    uint8 // 0-7
15514                                         LiqRenewable bool
15515                                         FlowRange    uint8
15516                                         DrownDmg     uint8
15517                                         Floodable    bool
15518
15519                                         DrawBox, ColBox, SelBox NodeBox
15520
15521                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15522
15523                                         LegacyFaceDir bool
15524                                         LegacyMounted bool
15525
15526                                         DigPredict string
15527
15528                                         MaxLvl uint8
15529
15530                                         AlphaUse
15531
15532                                         MoveResistance uint8
15533
15534                                         LiquidMovePhysics bool
15535                                 }))(obj)).OverlayTiles)[local242]).serialize(w)
15536                         }); err != nil {
15537                                 if err == io.EOF {
15538                                         chk(io.EOF)
15539                                 }
15540                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15541                         }
15542                 }
15543                 {
15544                         local243 := uint8(6)
15545                         {
15546                                 x := local243
15547                                 write8(w, uint8(x))
15548                         }
15549                 }
15550                 for local244 := range (*(*(struct {
15551                         Param0 Content
15552
15553                         Name   string
15554                         Groups []Group
15555
15556                         P1Type   Param1Type
15557                         P2Type   Param2Type
15558                         DrawType DrawType
15559
15560                         Mesh  string
15561                         Scale float32
15562                         //mt:const uint8(6)
15563                         Tiles        [6]TileDef
15564                         OverlayTiles [6]TileDef
15565                         //mt:const uint8(6)
15566                         SpecialTiles [6]TileDef
15567
15568                         Color   color.NRGBA
15569                         Palette Texture
15570
15571                         Waving       WaveType
15572                         ConnectSides uint8
15573                         ConnectTo    []Content
15574                         InsideTint   color.NRGBA
15575                         Level        uint8 // Must be < 128.
15576
15577                         Translucent bool // Sunlight is scattered and becomes normal light.
15578                         Transparent bool // Sunlight isn't scattered.
15579                         LightSrc    uint8
15580
15581                         GndContent   bool
15582                         Collides     bool
15583                         Pointable    bool
15584                         Diggable     bool
15585                         Climbable    bool
15586                         Replaceable  bool
15587                         OnRightClick bool
15588
15589                         DmgPerSec int32
15590
15591                         LiquidType   LiquidType
15592                         FlowingAlt   string
15593                         SrcAlt       string
15594                         Viscosity    uint8 // 0-7
15595                         LiqRenewable bool
15596                         FlowRange    uint8
15597                         DrownDmg     uint8
15598                         Floodable    bool
15599
15600                         DrawBox, ColBox, SelBox NodeBox
15601
15602                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15603
15604                         LegacyFaceDir bool
15605                         LegacyMounted bool
15606
15607                         DigPredict string
15608
15609                         MaxLvl uint8
15610
15611                         AlphaUse
15612
15613                         MoveResistance uint8
15614
15615                         LiquidMovePhysics bool
15616                 }))(obj)).SpecialTiles {
15617                         if err := pcall(func() {
15618                                 (((*(*(struct {
15619                                         Param0 Content
15620
15621                                         Name   string
15622                                         Groups []Group
15623
15624                                         P1Type   Param1Type
15625                                         P2Type   Param2Type
15626                                         DrawType DrawType
15627
15628                                         Mesh  string
15629                                         Scale float32
15630                                         //mt:const uint8(6)
15631                                         Tiles        [6]TileDef
15632                                         OverlayTiles [6]TileDef
15633                                         //mt:const uint8(6)
15634                                         SpecialTiles [6]TileDef
15635
15636                                         Color   color.NRGBA
15637                                         Palette Texture
15638
15639                                         Waving       WaveType
15640                                         ConnectSides uint8
15641                                         ConnectTo    []Content
15642                                         InsideTint   color.NRGBA
15643                                         Level        uint8 // Must be < 128.
15644
15645                                         Translucent bool // Sunlight is scattered and becomes normal light.
15646                                         Transparent bool // Sunlight isn't scattered.
15647                                         LightSrc    uint8
15648
15649                                         GndContent   bool
15650                                         Collides     bool
15651                                         Pointable    bool
15652                                         Diggable     bool
15653                                         Climbable    bool
15654                                         Replaceable  bool
15655                                         OnRightClick bool
15656
15657                                         DmgPerSec int32
15658
15659                                         LiquidType   LiquidType
15660                                         FlowingAlt   string
15661                                         SrcAlt       string
15662                                         Viscosity    uint8 // 0-7
15663                                         LiqRenewable bool
15664                                         FlowRange    uint8
15665                                         DrownDmg     uint8
15666                                         Floodable    bool
15667
15668                                         DrawBox, ColBox, SelBox NodeBox
15669
15670                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
15671
15672                                         LegacyFaceDir bool
15673                                         LegacyMounted bool
15674
15675                                         DigPredict string
15676
15677                                         MaxLvl uint8
15678
15679                                         AlphaUse
15680
15681                                         MoveResistance uint8
15682
15683                                         LiquidMovePhysics bool
15684                                 }))(obj)).SpecialTiles)[local244]).serialize(w)
15685                         }); err != nil {
15686                                 if err == io.EOF {
15687                                         chk(io.EOF)
15688                                 }
15689                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
15690                         }
15691                 }
15692                 {
15693                         x := (*(*(struct {
15694                                 Param0 Content
15695
15696                                 Name   string
15697                                 Groups []Group
15698
15699                                 P1Type   Param1Type
15700                                 P2Type   Param2Type
15701                                 DrawType DrawType
15702
15703                                 Mesh  string
15704                                 Scale float32
15705                                 //mt:const uint8(6)
15706                                 Tiles        [6]TileDef
15707                                 OverlayTiles [6]TileDef
15708                                 //mt:const uint8(6)
15709                                 SpecialTiles [6]TileDef
15710
15711                                 Color   color.NRGBA
15712                                 Palette Texture
15713
15714                                 Waving       WaveType
15715                                 ConnectSides uint8
15716                                 ConnectTo    []Content
15717                                 InsideTint   color.NRGBA
15718                                 Level        uint8 // Must be < 128.
15719
15720                                 Translucent bool // Sunlight is scattered and becomes normal light.
15721                                 Transparent bool // Sunlight isn't scattered.
15722                                 LightSrc    uint8
15723
15724                                 GndContent   bool
15725                                 Collides     bool
15726                                 Pointable    bool
15727                                 Diggable     bool
15728                                 Climbable    bool
15729                                 Replaceable  bool
15730                                 OnRightClick bool
15731
15732                                 DmgPerSec int32
15733
15734                                 LiquidType   LiquidType
15735                                 FlowingAlt   string
15736                                 SrcAlt       string
15737                                 Viscosity    uint8 // 0-7
15738                                 LiqRenewable bool
15739                                 FlowRange    uint8
15740                                 DrownDmg     uint8
15741                                 Floodable    bool
15742
15743                                 DrawBox, ColBox, SelBox NodeBox
15744
15745                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15746
15747                                 LegacyFaceDir bool
15748                                 LegacyMounted bool
15749
15750                                 DigPredict string
15751
15752                                 MaxLvl uint8
15753
15754                                 AlphaUse
15755
15756                                 MoveResistance uint8
15757
15758                                 LiquidMovePhysics bool
15759                         }))(obj)).Color
15760                         w.Write([]byte{x.A, x.R, x.G, x.B})
15761                 }
15762                 if err := pcall(func() {
15763                         ((*(*(struct {
15764                                 Param0 Content
15765
15766                                 Name   string
15767                                 Groups []Group
15768
15769                                 P1Type   Param1Type
15770                                 P2Type   Param2Type
15771                                 DrawType DrawType
15772
15773                                 Mesh  string
15774                                 Scale float32
15775                                 //mt:const uint8(6)
15776                                 Tiles        [6]TileDef
15777                                 OverlayTiles [6]TileDef
15778                                 //mt:const uint8(6)
15779                                 SpecialTiles [6]TileDef
15780
15781                                 Color   color.NRGBA
15782                                 Palette Texture
15783
15784                                 Waving       WaveType
15785                                 ConnectSides uint8
15786                                 ConnectTo    []Content
15787                                 InsideTint   color.NRGBA
15788                                 Level        uint8 // Must be < 128.
15789
15790                                 Translucent bool // Sunlight is scattered and becomes normal light.
15791                                 Transparent bool // Sunlight isn't scattered.
15792                                 LightSrc    uint8
15793
15794                                 GndContent   bool
15795                                 Collides     bool
15796                                 Pointable    bool
15797                                 Diggable     bool
15798                                 Climbable    bool
15799                                 Replaceable  bool
15800                                 OnRightClick bool
15801
15802                                 DmgPerSec int32
15803
15804                                 LiquidType   LiquidType
15805                                 FlowingAlt   string
15806                                 SrcAlt       string
15807                                 Viscosity    uint8 // 0-7
15808                                 LiqRenewable bool
15809                                 FlowRange    uint8
15810                                 DrownDmg     uint8
15811                                 Floodable    bool
15812
15813                                 DrawBox, ColBox, SelBox NodeBox
15814
15815                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15816
15817                                 LegacyFaceDir bool
15818                                 LegacyMounted bool
15819
15820                                 DigPredict string
15821
15822                                 MaxLvl uint8
15823
15824                                 AlphaUse
15825
15826                                 MoveResistance uint8
15827
15828                                 LiquidMovePhysics bool
15829                         }))(obj)).Palette).serialize(w)
15830                 }); err != nil {
15831                         if err == io.EOF {
15832                                 chk(io.EOF)
15833                         }
15834                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
15835                 }
15836                 if err := pcall(func() {
15837                         ((*(*(struct {
15838                                 Param0 Content
15839
15840                                 Name   string
15841                                 Groups []Group
15842
15843                                 P1Type   Param1Type
15844                                 P2Type   Param2Type
15845                                 DrawType DrawType
15846
15847                                 Mesh  string
15848                                 Scale float32
15849                                 //mt:const uint8(6)
15850                                 Tiles        [6]TileDef
15851                                 OverlayTiles [6]TileDef
15852                                 //mt:const uint8(6)
15853                                 SpecialTiles [6]TileDef
15854
15855                                 Color   color.NRGBA
15856                                 Palette Texture
15857
15858                                 Waving       WaveType
15859                                 ConnectSides uint8
15860                                 ConnectTo    []Content
15861                                 InsideTint   color.NRGBA
15862                                 Level        uint8 // Must be < 128.
15863
15864                                 Translucent bool // Sunlight is scattered and becomes normal light.
15865                                 Transparent bool // Sunlight isn't scattered.
15866                                 LightSrc    uint8
15867
15868                                 GndContent   bool
15869                                 Collides     bool
15870                                 Pointable    bool
15871                                 Diggable     bool
15872                                 Climbable    bool
15873                                 Replaceable  bool
15874                                 OnRightClick bool
15875
15876                                 DmgPerSec int32
15877
15878                                 LiquidType   LiquidType
15879                                 FlowingAlt   string
15880                                 SrcAlt       string
15881                                 Viscosity    uint8 // 0-7
15882                                 LiqRenewable bool
15883                                 FlowRange    uint8
15884                                 DrownDmg     uint8
15885                                 Floodable    bool
15886
15887                                 DrawBox, ColBox, SelBox NodeBox
15888
15889                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15890
15891                                 LegacyFaceDir bool
15892                                 LegacyMounted bool
15893
15894                                 DigPredict string
15895
15896                                 MaxLvl uint8
15897
15898                                 AlphaUse
15899
15900                                 MoveResistance uint8
15901
15902                                 LiquidMovePhysics bool
15903                         }))(obj)).Waving).serialize(w)
15904                 }); err != nil {
15905                         if err == io.EOF {
15906                                 chk(io.EOF)
15907                         }
15908                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.WaveType", err))
15909                 }
15910                 {
15911                         x := (*(*(struct {
15912                                 Param0 Content
15913
15914                                 Name   string
15915                                 Groups []Group
15916
15917                                 P1Type   Param1Type
15918                                 P2Type   Param2Type
15919                                 DrawType DrawType
15920
15921                                 Mesh  string
15922                                 Scale float32
15923                                 //mt:const uint8(6)
15924                                 Tiles        [6]TileDef
15925                                 OverlayTiles [6]TileDef
15926                                 //mt:const uint8(6)
15927                                 SpecialTiles [6]TileDef
15928
15929                                 Color   color.NRGBA
15930                                 Palette Texture
15931
15932                                 Waving       WaveType
15933                                 ConnectSides uint8
15934                                 ConnectTo    []Content
15935                                 InsideTint   color.NRGBA
15936                                 Level        uint8 // Must be < 128.
15937
15938                                 Translucent bool // Sunlight is scattered and becomes normal light.
15939                                 Transparent bool // Sunlight isn't scattered.
15940                                 LightSrc    uint8
15941
15942                                 GndContent   bool
15943                                 Collides     bool
15944                                 Pointable    bool
15945                                 Diggable     bool
15946                                 Climbable    bool
15947                                 Replaceable  bool
15948                                 OnRightClick bool
15949
15950                                 DmgPerSec int32
15951
15952                                 LiquidType   LiquidType
15953                                 FlowingAlt   string
15954                                 SrcAlt       string
15955                                 Viscosity    uint8 // 0-7
15956                                 LiqRenewable bool
15957                                 FlowRange    uint8
15958                                 DrownDmg     uint8
15959                                 Floodable    bool
15960
15961                                 DrawBox, ColBox, SelBox NodeBox
15962
15963                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
15964
15965                                 LegacyFaceDir bool
15966                                 LegacyMounted bool
15967
15968                                 DigPredict string
15969
15970                                 MaxLvl uint8
15971
15972                                 AlphaUse
15973
15974                                 MoveResistance uint8
15975
15976                                 LiquidMovePhysics bool
15977                         }))(obj)).ConnectSides
15978                         write8(w, uint8(x))
15979                 }
15980                 if len(((*(*(struct {
15981                         Param0 Content
15982
15983                         Name   string
15984                         Groups []Group
15985
15986                         P1Type   Param1Type
15987                         P2Type   Param2Type
15988                         DrawType DrawType
15989
15990                         Mesh  string
15991                         Scale float32
15992                         //mt:const uint8(6)
15993                         Tiles        [6]TileDef
15994                         OverlayTiles [6]TileDef
15995                         //mt:const uint8(6)
15996                         SpecialTiles [6]TileDef
15997
15998                         Color   color.NRGBA
15999                         Palette Texture
16000
16001                         Waving       WaveType
16002                         ConnectSides uint8
16003                         ConnectTo    []Content
16004                         InsideTint   color.NRGBA
16005                         Level        uint8 // Must be < 128.
16006
16007                         Translucent bool // Sunlight is scattered and becomes normal light.
16008                         Transparent bool // Sunlight isn't scattered.
16009                         LightSrc    uint8
16010
16011                         GndContent   bool
16012                         Collides     bool
16013                         Pointable    bool
16014                         Diggable     bool
16015                         Climbable    bool
16016                         Replaceable  bool
16017                         OnRightClick bool
16018
16019                         DmgPerSec int32
16020
16021                         LiquidType   LiquidType
16022                         FlowingAlt   string
16023                         SrcAlt       string
16024                         Viscosity    uint8 // 0-7
16025                         LiqRenewable bool
16026                         FlowRange    uint8
16027                         DrownDmg     uint8
16028                         Floodable    bool
16029
16030                         DrawBox, ColBox, SelBox NodeBox
16031
16032                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16033
16034                         LegacyFaceDir bool
16035                         LegacyMounted bool
16036
16037                         DigPredict string
16038
16039                         MaxLvl uint8
16040
16041                         AlphaUse
16042
16043                         MoveResistance uint8
16044
16045                         LiquidMovePhysics bool
16046                 }))(obj)).ConnectTo)) > math.MaxUint16 {
16047                         chk(ErrTooLong)
16048                 }
16049                 {
16050                         x := uint16(len(((*(*(struct {
16051                                 Param0 Content
16052
16053                                 Name   string
16054                                 Groups []Group
16055
16056                                 P1Type   Param1Type
16057                                 P2Type   Param2Type
16058                                 DrawType DrawType
16059
16060                                 Mesh  string
16061                                 Scale float32
16062                                 //mt:const uint8(6)
16063                                 Tiles        [6]TileDef
16064                                 OverlayTiles [6]TileDef
16065                                 //mt:const uint8(6)
16066                                 SpecialTiles [6]TileDef
16067
16068                                 Color   color.NRGBA
16069                                 Palette Texture
16070
16071                                 Waving       WaveType
16072                                 ConnectSides uint8
16073                                 ConnectTo    []Content
16074                                 InsideTint   color.NRGBA
16075                                 Level        uint8 // Must be < 128.
16076
16077                                 Translucent bool // Sunlight is scattered and becomes normal light.
16078                                 Transparent bool // Sunlight isn't scattered.
16079                                 LightSrc    uint8
16080
16081                                 GndContent   bool
16082                                 Collides     bool
16083                                 Pointable    bool
16084                                 Diggable     bool
16085                                 Climbable    bool
16086                                 Replaceable  bool
16087                                 OnRightClick bool
16088
16089                                 DmgPerSec int32
16090
16091                                 LiquidType   LiquidType
16092                                 FlowingAlt   string
16093                                 SrcAlt       string
16094                                 Viscosity    uint8 // 0-7
16095                                 LiqRenewable bool
16096                                 FlowRange    uint8
16097                                 DrownDmg     uint8
16098                                 Floodable    bool
16099
16100                                 DrawBox, ColBox, SelBox NodeBox
16101
16102                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16103
16104                                 LegacyFaceDir bool
16105                                 LegacyMounted bool
16106
16107                                 DigPredict string
16108
16109                                 MaxLvl uint8
16110
16111                                 AlphaUse
16112
16113                                 MoveResistance uint8
16114
16115                                 LiquidMovePhysics bool
16116                         }))(obj)).ConnectTo)))
16117                         write16(w, uint16(x))
16118                 }
16119                 for local245 := range (*(*(struct {
16120                         Param0 Content
16121
16122                         Name   string
16123                         Groups []Group
16124
16125                         P1Type   Param1Type
16126                         P2Type   Param2Type
16127                         DrawType DrawType
16128
16129                         Mesh  string
16130                         Scale float32
16131                         //mt:const uint8(6)
16132                         Tiles        [6]TileDef
16133                         OverlayTiles [6]TileDef
16134                         //mt:const uint8(6)
16135                         SpecialTiles [6]TileDef
16136
16137                         Color   color.NRGBA
16138                         Palette Texture
16139
16140                         Waving       WaveType
16141                         ConnectSides uint8
16142                         ConnectTo    []Content
16143                         InsideTint   color.NRGBA
16144                         Level        uint8 // Must be < 128.
16145
16146                         Translucent bool // Sunlight is scattered and becomes normal light.
16147                         Transparent bool // Sunlight isn't scattered.
16148                         LightSrc    uint8
16149
16150                         GndContent   bool
16151                         Collides     bool
16152                         Pointable    bool
16153                         Diggable     bool
16154                         Climbable    bool
16155                         Replaceable  bool
16156                         OnRightClick bool
16157
16158                         DmgPerSec int32
16159
16160                         LiquidType   LiquidType
16161                         FlowingAlt   string
16162                         SrcAlt       string
16163                         Viscosity    uint8 // 0-7
16164                         LiqRenewable bool
16165                         FlowRange    uint8
16166                         DrownDmg     uint8
16167                         Floodable    bool
16168
16169                         DrawBox, ColBox, SelBox NodeBox
16170
16171                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16172
16173                         LegacyFaceDir bool
16174                         LegacyMounted bool
16175
16176                         DigPredict string
16177
16178                         MaxLvl uint8
16179
16180                         AlphaUse
16181
16182                         MoveResistance uint8
16183
16184                         LiquidMovePhysics bool
16185                 }))(obj)).ConnectTo {
16186                         if err := pcall(func() {
16187                                 (((*(*(struct {
16188                                         Param0 Content
16189
16190                                         Name   string
16191                                         Groups []Group
16192
16193                                         P1Type   Param1Type
16194                                         P2Type   Param2Type
16195                                         DrawType DrawType
16196
16197                                         Mesh  string
16198                                         Scale float32
16199                                         //mt:const uint8(6)
16200                                         Tiles        [6]TileDef
16201                                         OverlayTiles [6]TileDef
16202                                         //mt:const uint8(6)
16203                                         SpecialTiles [6]TileDef
16204
16205                                         Color   color.NRGBA
16206                                         Palette Texture
16207
16208                                         Waving       WaveType
16209                                         ConnectSides uint8
16210                                         ConnectTo    []Content
16211                                         InsideTint   color.NRGBA
16212                                         Level        uint8 // Must be < 128.
16213
16214                                         Translucent bool // Sunlight is scattered and becomes normal light.
16215                                         Transparent bool // Sunlight isn't scattered.
16216                                         LightSrc    uint8
16217
16218                                         GndContent   bool
16219                                         Collides     bool
16220                                         Pointable    bool
16221                                         Diggable     bool
16222                                         Climbable    bool
16223                                         Replaceable  bool
16224                                         OnRightClick bool
16225
16226                                         DmgPerSec int32
16227
16228                                         LiquidType   LiquidType
16229                                         FlowingAlt   string
16230                                         SrcAlt       string
16231                                         Viscosity    uint8 // 0-7
16232                                         LiqRenewable bool
16233                                         FlowRange    uint8
16234                                         DrownDmg     uint8
16235                                         Floodable    bool
16236
16237                                         DrawBox, ColBox, SelBox NodeBox
16238
16239                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
16240
16241                                         LegacyFaceDir bool
16242                                         LegacyMounted bool
16243
16244                                         DigPredict string
16245
16246                                         MaxLvl uint8
16247
16248                                         AlphaUse
16249
16250                                         MoveResistance uint8
16251
16252                                         LiquidMovePhysics bool
16253                                 }))(obj)).ConnectTo)[local245]).serialize(w)
16254                         }); err != nil {
16255                                 if err == io.EOF {
16256                                         chk(io.EOF)
16257                                 }
16258                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
16259                         }
16260                 }
16261                 {
16262                         x := (*(*(struct {
16263                                 Param0 Content
16264
16265                                 Name   string
16266                                 Groups []Group
16267
16268                                 P1Type   Param1Type
16269                                 P2Type   Param2Type
16270                                 DrawType DrawType
16271
16272                                 Mesh  string
16273                                 Scale float32
16274                                 //mt:const uint8(6)
16275                                 Tiles        [6]TileDef
16276                                 OverlayTiles [6]TileDef
16277                                 //mt:const uint8(6)
16278                                 SpecialTiles [6]TileDef
16279
16280                                 Color   color.NRGBA
16281                                 Palette Texture
16282
16283                                 Waving       WaveType
16284                                 ConnectSides uint8
16285                                 ConnectTo    []Content
16286                                 InsideTint   color.NRGBA
16287                                 Level        uint8 // Must be < 128.
16288
16289                                 Translucent bool // Sunlight is scattered and becomes normal light.
16290                                 Transparent bool // Sunlight isn't scattered.
16291                                 LightSrc    uint8
16292
16293                                 GndContent   bool
16294                                 Collides     bool
16295                                 Pointable    bool
16296                                 Diggable     bool
16297                                 Climbable    bool
16298                                 Replaceable  bool
16299                                 OnRightClick bool
16300
16301                                 DmgPerSec int32
16302
16303                                 LiquidType   LiquidType
16304                                 FlowingAlt   string
16305                                 SrcAlt       string
16306                                 Viscosity    uint8 // 0-7
16307                                 LiqRenewable bool
16308                                 FlowRange    uint8
16309                                 DrownDmg     uint8
16310                                 Floodable    bool
16311
16312                                 DrawBox, ColBox, SelBox NodeBox
16313
16314                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16315
16316                                 LegacyFaceDir bool
16317                                 LegacyMounted bool
16318
16319                                 DigPredict string
16320
16321                                 MaxLvl uint8
16322
16323                                 AlphaUse
16324
16325                                 MoveResistance uint8
16326
16327                                 LiquidMovePhysics bool
16328                         }))(obj)).InsideTint
16329                         w.Write([]byte{x.A, x.R, x.G, x.B})
16330                 }
16331                 {
16332                         x := (*(*(struct {
16333                                 Param0 Content
16334
16335                                 Name   string
16336                                 Groups []Group
16337
16338                                 P1Type   Param1Type
16339                                 P2Type   Param2Type
16340                                 DrawType DrawType
16341
16342                                 Mesh  string
16343                                 Scale float32
16344                                 //mt:const uint8(6)
16345                                 Tiles        [6]TileDef
16346                                 OverlayTiles [6]TileDef
16347                                 //mt:const uint8(6)
16348                                 SpecialTiles [6]TileDef
16349
16350                                 Color   color.NRGBA
16351                                 Palette Texture
16352
16353                                 Waving       WaveType
16354                                 ConnectSides uint8
16355                                 ConnectTo    []Content
16356                                 InsideTint   color.NRGBA
16357                                 Level        uint8 // Must be < 128.
16358
16359                                 Translucent bool // Sunlight is scattered and becomes normal light.
16360                                 Transparent bool // Sunlight isn't scattered.
16361                                 LightSrc    uint8
16362
16363                                 GndContent   bool
16364                                 Collides     bool
16365                                 Pointable    bool
16366                                 Diggable     bool
16367                                 Climbable    bool
16368                                 Replaceable  bool
16369                                 OnRightClick bool
16370
16371                                 DmgPerSec int32
16372
16373                                 LiquidType   LiquidType
16374                                 FlowingAlt   string
16375                                 SrcAlt       string
16376                                 Viscosity    uint8 // 0-7
16377                                 LiqRenewable bool
16378                                 FlowRange    uint8
16379                                 DrownDmg     uint8
16380                                 Floodable    bool
16381
16382                                 DrawBox, ColBox, SelBox NodeBox
16383
16384                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16385
16386                                 LegacyFaceDir bool
16387                                 LegacyMounted bool
16388
16389                                 DigPredict string
16390
16391                                 MaxLvl uint8
16392
16393                                 AlphaUse
16394
16395                                 MoveResistance uint8
16396
16397                                 LiquidMovePhysics bool
16398                         }))(obj)).Level
16399                         write8(w, uint8(x))
16400                 }
16401                 {
16402                         x := (*(*(struct {
16403                                 Param0 Content
16404
16405                                 Name   string
16406                                 Groups []Group
16407
16408                                 P1Type   Param1Type
16409                                 P2Type   Param2Type
16410                                 DrawType DrawType
16411
16412                                 Mesh  string
16413                                 Scale float32
16414                                 //mt:const uint8(6)
16415                                 Tiles        [6]TileDef
16416                                 OverlayTiles [6]TileDef
16417                                 //mt:const uint8(6)
16418                                 SpecialTiles [6]TileDef
16419
16420                                 Color   color.NRGBA
16421                                 Palette Texture
16422
16423                                 Waving       WaveType
16424                                 ConnectSides uint8
16425                                 ConnectTo    []Content
16426                                 InsideTint   color.NRGBA
16427                                 Level        uint8 // Must be < 128.
16428
16429                                 Translucent bool // Sunlight is scattered and becomes normal light.
16430                                 Transparent bool // Sunlight isn't scattered.
16431                                 LightSrc    uint8
16432
16433                                 GndContent   bool
16434                                 Collides     bool
16435                                 Pointable    bool
16436                                 Diggable     bool
16437                                 Climbable    bool
16438                                 Replaceable  bool
16439                                 OnRightClick bool
16440
16441                                 DmgPerSec int32
16442
16443                                 LiquidType   LiquidType
16444                                 FlowingAlt   string
16445                                 SrcAlt       string
16446                                 Viscosity    uint8 // 0-7
16447                                 LiqRenewable bool
16448                                 FlowRange    uint8
16449                                 DrownDmg     uint8
16450                                 Floodable    bool
16451
16452                                 DrawBox, ColBox, SelBox NodeBox
16453
16454                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16455
16456                                 LegacyFaceDir bool
16457                                 LegacyMounted bool
16458
16459                                 DigPredict string
16460
16461                                 MaxLvl uint8
16462
16463                                 AlphaUse
16464
16465                                 MoveResistance uint8
16466
16467                                 LiquidMovePhysics bool
16468                         }))(obj)).Translucent
16469                         if x {
16470                                 write8(w, 1)
16471                         } else {
16472                                 write8(w, 0)
16473                         }
16474                 }
16475                 {
16476                         x := (*(*(struct {
16477                                 Param0 Content
16478
16479                                 Name   string
16480                                 Groups []Group
16481
16482                                 P1Type   Param1Type
16483                                 P2Type   Param2Type
16484                                 DrawType DrawType
16485
16486                                 Mesh  string
16487                                 Scale float32
16488                                 //mt:const uint8(6)
16489                                 Tiles        [6]TileDef
16490                                 OverlayTiles [6]TileDef
16491                                 //mt:const uint8(6)
16492                                 SpecialTiles [6]TileDef
16493
16494                                 Color   color.NRGBA
16495                                 Palette Texture
16496
16497                                 Waving       WaveType
16498                                 ConnectSides uint8
16499                                 ConnectTo    []Content
16500                                 InsideTint   color.NRGBA
16501                                 Level        uint8 // Must be < 128.
16502
16503                                 Translucent bool // Sunlight is scattered and becomes normal light.
16504                                 Transparent bool // Sunlight isn't scattered.
16505                                 LightSrc    uint8
16506
16507                                 GndContent   bool
16508                                 Collides     bool
16509                                 Pointable    bool
16510                                 Diggable     bool
16511                                 Climbable    bool
16512                                 Replaceable  bool
16513                                 OnRightClick bool
16514
16515                                 DmgPerSec int32
16516
16517                                 LiquidType   LiquidType
16518                                 FlowingAlt   string
16519                                 SrcAlt       string
16520                                 Viscosity    uint8 // 0-7
16521                                 LiqRenewable bool
16522                                 FlowRange    uint8
16523                                 DrownDmg     uint8
16524                                 Floodable    bool
16525
16526                                 DrawBox, ColBox, SelBox NodeBox
16527
16528                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16529
16530                                 LegacyFaceDir bool
16531                                 LegacyMounted bool
16532
16533                                 DigPredict string
16534
16535                                 MaxLvl uint8
16536
16537                                 AlphaUse
16538
16539                                 MoveResistance uint8
16540
16541                                 LiquidMovePhysics bool
16542                         }))(obj)).Transparent
16543                         if x {
16544                                 write8(w, 1)
16545                         } else {
16546                                 write8(w, 0)
16547                         }
16548                 }
16549                 {
16550                         x := (*(*(struct {
16551                                 Param0 Content
16552
16553                                 Name   string
16554                                 Groups []Group
16555
16556                                 P1Type   Param1Type
16557                                 P2Type   Param2Type
16558                                 DrawType DrawType
16559
16560                                 Mesh  string
16561                                 Scale float32
16562                                 //mt:const uint8(6)
16563                                 Tiles        [6]TileDef
16564                                 OverlayTiles [6]TileDef
16565                                 //mt:const uint8(6)
16566                                 SpecialTiles [6]TileDef
16567
16568                                 Color   color.NRGBA
16569                                 Palette Texture
16570
16571                                 Waving       WaveType
16572                                 ConnectSides uint8
16573                                 ConnectTo    []Content
16574                                 InsideTint   color.NRGBA
16575                                 Level        uint8 // Must be < 128.
16576
16577                                 Translucent bool // Sunlight is scattered and becomes normal light.
16578                                 Transparent bool // Sunlight isn't scattered.
16579                                 LightSrc    uint8
16580
16581                                 GndContent   bool
16582                                 Collides     bool
16583                                 Pointable    bool
16584                                 Diggable     bool
16585                                 Climbable    bool
16586                                 Replaceable  bool
16587                                 OnRightClick bool
16588
16589                                 DmgPerSec int32
16590
16591                                 LiquidType   LiquidType
16592                                 FlowingAlt   string
16593                                 SrcAlt       string
16594                                 Viscosity    uint8 // 0-7
16595                                 LiqRenewable bool
16596                                 FlowRange    uint8
16597                                 DrownDmg     uint8
16598                                 Floodable    bool
16599
16600                                 DrawBox, ColBox, SelBox NodeBox
16601
16602                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16603
16604                                 LegacyFaceDir bool
16605                                 LegacyMounted bool
16606
16607                                 DigPredict string
16608
16609                                 MaxLvl uint8
16610
16611                                 AlphaUse
16612
16613                                 MoveResistance uint8
16614
16615                                 LiquidMovePhysics bool
16616                         }))(obj)).LightSrc
16617                         write8(w, uint8(x))
16618                 }
16619                 {
16620                         x := (*(*(struct {
16621                                 Param0 Content
16622
16623                                 Name   string
16624                                 Groups []Group
16625
16626                                 P1Type   Param1Type
16627                                 P2Type   Param2Type
16628                                 DrawType DrawType
16629
16630                                 Mesh  string
16631                                 Scale float32
16632                                 //mt:const uint8(6)
16633                                 Tiles        [6]TileDef
16634                                 OverlayTiles [6]TileDef
16635                                 //mt:const uint8(6)
16636                                 SpecialTiles [6]TileDef
16637
16638                                 Color   color.NRGBA
16639                                 Palette Texture
16640
16641                                 Waving       WaveType
16642                                 ConnectSides uint8
16643                                 ConnectTo    []Content
16644                                 InsideTint   color.NRGBA
16645                                 Level        uint8 // Must be < 128.
16646
16647                                 Translucent bool // Sunlight is scattered and becomes normal light.
16648                                 Transparent bool // Sunlight isn't scattered.
16649                                 LightSrc    uint8
16650
16651                                 GndContent   bool
16652                                 Collides     bool
16653                                 Pointable    bool
16654                                 Diggable     bool
16655                                 Climbable    bool
16656                                 Replaceable  bool
16657                                 OnRightClick bool
16658
16659                                 DmgPerSec int32
16660
16661                                 LiquidType   LiquidType
16662                                 FlowingAlt   string
16663                                 SrcAlt       string
16664                                 Viscosity    uint8 // 0-7
16665                                 LiqRenewable bool
16666                                 FlowRange    uint8
16667                                 DrownDmg     uint8
16668                                 Floodable    bool
16669
16670                                 DrawBox, ColBox, SelBox NodeBox
16671
16672                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16673
16674                                 LegacyFaceDir bool
16675                                 LegacyMounted bool
16676
16677                                 DigPredict string
16678
16679                                 MaxLvl uint8
16680
16681                                 AlphaUse
16682
16683                                 MoveResistance uint8
16684
16685                                 LiquidMovePhysics bool
16686                         }))(obj)).GndContent
16687                         if x {
16688                                 write8(w, 1)
16689                         } else {
16690                                 write8(w, 0)
16691                         }
16692                 }
16693                 {
16694                         x := (*(*(struct {
16695                                 Param0 Content
16696
16697                                 Name   string
16698                                 Groups []Group
16699
16700                                 P1Type   Param1Type
16701                                 P2Type   Param2Type
16702                                 DrawType DrawType
16703
16704                                 Mesh  string
16705                                 Scale float32
16706                                 //mt:const uint8(6)
16707                                 Tiles        [6]TileDef
16708                                 OverlayTiles [6]TileDef
16709                                 //mt:const uint8(6)
16710                                 SpecialTiles [6]TileDef
16711
16712                                 Color   color.NRGBA
16713                                 Palette Texture
16714
16715                                 Waving       WaveType
16716                                 ConnectSides uint8
16717                                 ConnectTo    []Content
16718                                 InsideTint   color.NRGBA
16719                                 Level        uint8 // Must be < 128.
16720
16721                                 Translucent bool // Sunlight is scattered and becomes normal light.
16722                                 Transparent bool // Sunlight isn't scattered.
16723                                 LightSrc    uint8
16724
16725                                 GndContent   bool
16726                                 Collides     bool
16727                                 Pointable    bool
16728                                 Diggable     bool
16729                                 Climbable    bool
16730                                 Replaceable  bool
16731                                 OnRightClick bool
16732
16733                                 DmgPerSec int32
16734
16735                                 LiquidType   LiquidType
16736                                 FlowingAlt   string
16737                                 SrcAlt       string
16738                                 Viscosity    uint8 // 0-7
16739                                 LiqRenewable bool
16740                                 FlowRange    uint8
16741                                 DrownDmg     uint8
16742                                 Floodable    bool
16743
16744                                 DrawBox, ColBox, SelBox NodeBox
16745
16746                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16747
16748                                 LegacyFaceDir bool
16749                                 LegacyMounted bool
16750
16751                                 DigPredict string
16752
16753                                 MaxLvl uint8
16754
16755                                 AlphaUse
16756
16757                                 MoveResistance uint8
16758
16759                                 LiquidMovePhysics bool
16760                         }))(obj)).Collides
16761                         if x {
16762                                 write8(w, 1)
16763                         } else {
16764                                 write8(w, 0)
16765                         }
16766                 }
16767                 {
16768                         x := (*(*(struct {
16769                                 Param0 Content
16770
16771                                 Name   string
16772                                 Groups []Group
16773
16774                                 P1Type   Param1Type
16775                                 P2Type   Param2Type
16776                                 DrawType DrawType
16777
16778                                 Mesh  string
16779                                 Scale float32
16780                                 //mt:const uint8(6)
16781                                 Tiles        [6]TileDef
16782                                 OverlayTiles [6]TileDef
16783                                 //mt:const uint8(6)
16784                                 SpecialTiles [6]TileDef
16785
16786                                 Color   color.NRGBA
16787                                 Palette Texture
16788
16789                                 Waving       WaveType
16790                                 ConnectSides uint8
16791                                 ConnectTo    []Content
16792                                 InsideTint   color.NRGBA
16793                                 Level        uint8 // Must be < 128.
16794
16795                                 Translucent bool // Sunlight is scattered and becomes normal light.
16796                                 Transparent bool // Sunlight isn't scattered.
16797                                 LightSrc    uint8
16798
16799                                 GndContent   bool
16800                                 Collides     bool
16801                                 Pointable    bool
16802                                 Diggable     bool
16803                                 Climbable    bool
16804                                 Replaceable  bool
16805                                 OnRightClick bool
16806
16807                                 DmgPerSec int32
16808
16809                                 LiquidType   LiquidType
16810                                 FlowingAlt   string
16811                                 SrcAlt       string
16812                                 Viscosity    uint8 // 0-7
16813                                 LiqRenewable bool
16814                                 FlowRange    uint8
16815                                 DrownDmg     uint8
16816                                 Floodable    bool
16817
16818                                 DrawBox, ColBox, SelBox NodeBox
16819
16820                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16821
16822                                 LegacyFaceDir bool
16823                                 LegacyMounted bool
16824
16825                                 DigPredict string
16826
16827                                 MaxLvl uint8
16828
16829                                 AlphaUse
16830
16831                                 MoveResistance uint8
16832
16833                                 LiquidMovePhysics bool
16834                         }))(obj)).Pointable
16835                         if x {
16836                                 write8(w, 1)
16837                         } else {
16838                                 write8(w, 0)
16839                         }
16840                 }
16841                 {
16842                         x := (*(*(struct {
16843                                 Param0 Content
16844
16845                                 Name   string
16846                                 Groups []Group
16847
16848                                 P1Type   Param1Type
16849                                 P2Type   Param2Type
16850                                 DrawType DrawType
16851
16852                                 Mesh  string
16853                                 Scale float32
16854                                 //mt:const uint8(6)
16855                                 Tiles        [6]TileDef
16856                                 OverlayTiles [6]TileDef
16857                                 //mt:const uint8(6)
16858                                 SpecialTiles [6]TileDef
16859
16860                                 Color   color.NRGBA
16861                                 Palette Texture
16862
16863                                 Waving       WaveType
16864                                 ConnectSides uint8
16865                                 ConnectTo    []Content
16866                                 InsideTint   color.NRGBA
16867                                 Level        uint8 // Must be < 128.
16868
16869                                 Translucent bool // Sunlight is scattered and becomes normal light.
16870                                 Transparent bool // Sunlight isn't scattered.
16871                                 LightSrc    uint8
16872
16873                                 GndContent   bool
16874                                 Collides     bool
16875                                 Pointable    bool
16876                                 Diggable     bool
16877                                 Climbable    bool
16878                                 Replaceable  bool
16879                                 OnRightClick bool
16880
16881                                 DmgPerSec int32
16882
16883                                 LiquidType   LiquidType
16884                                 FlowingAlt   string
16885                                 SrcAlt       string
16886                                 Viscosity    uint8 // 0-7
16887                                 LiqRenewable bool
16888                                 FlowRange    uint8
16889                                 DrownDmg     uint8
16890                                 Floodable    bool
16891
16892                                 DrawBox, ColBox, SelBox NodeBox
16893
16894                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16895
16896                                 LegacyFaceDir bool
16897                                 LegacyMounted bool
16898
16899                                 DigPredict string
16900
16901                                 MaxLvl uint8
16902
16903                                 AlphaUse
16904
16905                                 MoveResistance uint8
16906
16907                                 LiquidMovePhysics bool
16908                         }))(obj)).Diggable
16909                         if x {
16910                                 write8(w, 1)
16911                         } else {
16912                                 write8(w, 0)
16913                         }
16914                 }
16915                 {
16916                         x := (*(*(struct {
16917                                 Param0 Content
16918
16919                                 Name   string
16920                                 Groups []Group
16921
16922                                 P1Type   Param1Type
16923                                 P2Type   Param2Type
16924                                 DrawType DrawType
16925
16926                                 Mesh  string
16927                                 Scale float32
16928                                 //mt:const uint8(6)
16929                                 Tiles        [6]TileDef
16930                                 OverlayTiles [6]TileDef
16931                                 //mt:const uint8(6)
16932                                 SpecialTiles [6]TileDef
16933
16934                                 Color   color.NRGBA
16935                                 Palette Texture
16936
16937                                 Waving       WaveType
16938                                 ConnectSides uint8
16939                                 ConnectTo    []Content
16940                                 InsideTint   color.NRGBA
16941                                 Level        uint8 // Must be < 128.
16942
16943                                 Translucent bool // Sunlight is scattered and becomes normal light.
16944                                 Transparent bool // Sunlight isn't scattered.
16945                                 LightSrc    uint8
16946
16947                                 GndContent   bool
16948                                 Collides     bool
16949                                 Pointable    bool
16950                                 Diggable     bool
16951                                 Climbable    bool
16952                                 Replaceable  bool
16953                                 OnRightClick bool
16954
16955                                 DmgPerSec int32
16956
16957                                 LiquidType   LiquidType
16958                                 FlowingAlt   string
16959                                 SrcAlt       string
16960                                 Viscosity    uint8 // 0-7
16961                                 LiqRenewable bool
16962                                 FlowRange    uint8
16963                                 DrownDmg     uint8
16964                                 Floodable    bool
16965
16966                                 DrawBox, ColBox, SelBox NodeBox
16967
16968                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
16969
16970                                 LegacyFaceDir bool
16971                                 LegacyMounted bool
16972
16973                                 DigPredict string
16974
16975                                 MaxLvl uint8
16976
16977                                 AlphaUse
16978
16979                                 MoveResistance uint8
16980
16981                                 LiquidMovePhysics bool
16982                         }))(obj)).Climbable
16983                         if x {
16984                                 write8(w, 1)
16985                         } else {
16986                                 write8(w, 0)
16987                         }
16988                 }
16989                 {
16990                         x := (*(*(struct {
16991                                 Param0 Content
16992
16993                                 Name   string
16994                                 Groups []Group
16995
16996                                 P1Type   Param1Type
16997                                 P2Type   Param2Type
16998                                 DrawType DrawType
16999
17000                                 Mesh  string
17001                                 Scale float32
17002                                 //mt:const uint8(6)
17003                                 Tiles        [6]TileDef
17004                                 OverlayTiles [6]TileDef
17005                                 //mt:const uint8(6)
17006                                 SpecialTiles [6]TileDef
17007
17008                                 Color   color.NRGBA
17009                                 Palette Texture
17010
17011                                 Waving       WaveType
17012                                 ConnectSides uint8
17013                                 ConnectTo    []Content
17014                                 InsideTint   color.NRGBA
17015                                 Level        uint8 // Must be < 128.
17016
17017                                 Translucent bool // Sunlight is scattered and becomes normal light.
17018                                 Transparent bool // Sunlight isn't scattered.
17019                                 LightSrc    uint8
17020
17021                                 GndContent   bool
17022                                 Collides     bool
17023                                 Pointable    bool
17024                                 Diggable     bool
17025                                 Climbable    bool
17026                                 Replaceable  bool
17027                                 OnRightClick bool
17028
17029                                 DmgPerSec int32
17030
17031                                 LiquidType   LiquidType
17032                                 FlowingAlt   string
17033                                 SrcAlt       string
17034                                 Viscosity    uint8 // 0-7
17035                                 LiqRenewable bool
17036                                 FlowRange    uint8
17037                                 DrownDmg     uint8
17038                                 Floodable    bool
17039
17040                                 DrawBox, ColBox, SelBox NodeBox
17041
17042                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17043
17044                                 LegacyFaceDir bool
17045                                 LegacyMounted bool
17046
17047                                 DigPredict string
17048
17049                                 MaxLvl uint8
17050
17051                                 AlphaUse
17052
17053                                 MoveResistance uint8
17054
17055                                 LiquidMovePhysics bool
17056                         }))(obj)).Replaceable
17057                         if x {
17058                                 write8(w, 1)
17059                         } else {
17060                                 write8(w, 0)
17061                         }
17062                 }
17063                 {
17064                         x := (*(*(struct {
17065                                 Param0 Content
17066
17067                                 Name   string
17068                                 Groups []Group
17069
17070                                 P1Type   Param1Type
17071                                 P2Type   Param2Type
17072                                 DrawType DrawType
17073
17074                                 Mesh  string
17075                                 Scale float32
17076                                 //mt:const uint8(6)
17077                                 Tiles        [6]TileDef
17078                                 OverlayTiles [6]TileDef
17079                                 //mt:const uint8(6)
17080                                 SpecialTiles [6]TileDef
17081
17082                                 Color   color.NRGBA
17083                                 Palette Texture
17084
17085                                 Waving       WaveType
17086                                 ConnectSides uint8
17087                                 ConnectTo    []Content
17088                                 InsideTint   color.NRGBA
17089                                 Level        uint8 // Must be < 128.
17090
17091                                 Translucent bool // Sunlight is scattered and becomes normal light.
17092                                 Transparent bool // Sunlight isn't scattered.
17093                                 LightSrc    uint8
17094
17095                                 GndContent   bool
17096                                 Collides     bool
17097                                 Pointable    bool
17098                                 Diggable     bool
17099                                 Climbable    bool
17100                                 Replaceable  bool
17101                                 OnRightClick bool
17102
17103                                 DmgPerSec int32
17104
17105                                 LiquidType   LiquidType
17106                                 FlowingAlt   string
17107                                 SrcAlt       string
17108                                 Viscosity    uint8 // 0-7
17109                                 LiqRenewable bool
17110                                 FlowRange    uint8
17111                                 DrownDmg     uint8
17112                                 Floodable    bool
17113
17114                                 DrawBox, ColBox, SelBox NodeBox
17115
17116                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17117
17118                                 LegacyFaceDir bool
17119                                 LegacyMounted bool
17120
17121                                 DigPredict string
17122
17123                                 MaxLvl uint8
17124
17125                                 AlphaUse
17126
17127                                 MoveResistance uint8
17128
17129                                 LiquidMovePhysics bool
17130                         }))(obj)).OnRightClick
17131                         if x {
17132                                 write8(w, 1)
17133                         } else {
17134                                 write8(w, 0)
17135                         }
17136                 }
17137                 {
17138                         x := (*(*(struct {
17139                                 Param0 Content
17140
17141                                 Name   string
17142                                 Groups []Group
17143
17144                                 P1Type   Param1Type
17145                                 P2Type   Param2Type
17146                                 DrawType DrawType
17147
17148                                 Mesh  string
17149                                 Scale float32
17150                                 //mt:const uint8(6)
17151                                 Tiles        [6]TileDef
17152                                 OverlayTiles [6]TileDef
17153                                 //mt:const uint8(6)
17154                                 SpecialTiles [6]TileDef
17155
17156                                 Color   color.NRGBA
17157                                 Palette Texture
17158
17159                                 Waving       WaveType
17160                                 ConnectSides uint8
17161                                 ConnectTo    []Content
17162                                 InsideTint   color.NRGBA
17163                                 Level        uint8 // Must be < 128.
17164
17165                                 Translucent bool // Sunlight is scattered and becomes normal light.
17166                                 Transparent bool // Sunlight isn't scattered.
17167                                 LightSrc    uint8
17168
17169                                 GndContent   bool
17170                                 Collides     bool
17171                                 Pointable    bool
17172                                 Diggable     bool
17173                                 Climbable    bool
17174                                 Replaceable  bool
17175                                 OnRightClick bool
17176
17177                                 DmgPerSec int32
17178
17179                                 LiquidType   LiquidType
17180                                 FlowingAlt   string
17181                                 SrcAlt       string
17182                                 Viscosity    uint8 // 0-7
17183                                 LiqRenewable bool
17184                                 FlowRange    uint8
17185                                 DrownDmg     uint8
17186                                 Floodable    bool
17187
17188                                 DrawBox, ColBox, SelBox NodeBox
17189
17190                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17191
17192                                 LegacyFaceDir bool
17193                                 LegacyMounted bool
17194
17195                                 DigPredict string
17196
17197                                 MaxLvl uint8
17198
17199                                 AlphaUse
17200
17201                                 MoveResistance uint8
17202
17203                                 LiquidMovePhysics bool
17204                         }))(obj)).DmgPerSec
17205                         write32(w, uint32(x))
17206                 }
17207                 if err := pcall(func() {
17208                         ((*(*(struct {
17209                                 Param0 Content
17210
17211                                 Name   string
17212                                 Groups []Group
17213
17214                                 P1Type   Param1Type
17215                                 P2Type   Param2Type
17216                                 DrawType DrawType
17217
17218                                 Mesh  string
17219                                 Scale float32
17220                                 //mt:const uint8(6)
17221                                 Tiles        [6]TileDef
17222                                 OverlayTiles [6]TileDef
17223                                 //mt:const uint8(6)
17224                                 SpecialTiles [6]TileDef
17225
17226                                 Color   color.NRGBA
17227                                 Palette Texture
17228
17229                                 Waving       WaveType
17230                                 ConnectSides uint8
17231                                 ConnectTo    []Content
17232                                 InsideTint   color.NRGBA
17233                                 Level        uint8 // Must be < 128.
17234
17235                                 Translucent bool // Sunlight is scattered and becomes normal light.
17236                                 Transparent bool // Sunlight isn't scattered.
17237                                 LightSrc    uint8
17238
17239                                 GndContent   bool
17240                                 Collides     bool
17241                                 Pointable    bool
17242                                 Diggable     bool
17243                                 Climbable    bool
17244                                 Replaceable  bool
17245                                 OnRightClick bool
17246
17247                                 DmgPerSec int32
17248
17249                                 LiquidType   LiquidType
17250                                 FlowingAlt   string
17251                                 SrcAlt       string
17252                                 Viscosity    uint8 // 0-7
17253                                 LiqRenewable bool
17254                                 FlowRange    uint8
17255                                 DrownDmg     uint8
17256                                 Floodable    bool
17257
17258                                 DrawBox, ColBox, SelBox NodeBox
17259
17260                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17261
17262                                 LegacyFaceDir bool
17263                                 LegacyMounted bool
17264
17265                                 DigPredict string
17266
17267                                 MaxLvl uint8
17268
17269                                 AlphaUse
17270
17271                                 MoveResistance uint8
17272
17273                                 LiquidMovePhysics bool
17274                         }))(obj)).LiquidType).serialize(w)
17275                 }); err != nil {
17276                         if err == io.EOF {
17277                                 chk(io.EOF)
17278                         }
17279                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LiquidType", err))
17280                 }
17281                 if len(([]byte((*(*(struct {
17282                         Param0 Content
17283
17284                         Name   string
17285                         Groups []Group
17286
17287                         P1Type   Param1Type
17288                         P2Type   Param2Type
17289                         DrawType DrawType
17290
17291                         Mesh  string
17292                         Scale float32
17293                         //mt:const uint8(6)
17294                         Tiles        [6]TileDef
17295                         OverlayTiles [6]TileDef
17296                         //mt:const uint8(6)
17297                         SpecialTiles [6]TileDef
17298
17299                         Color   color.NRGBA
17300                         Palette Texture
17301
17302                         Waving       WaveType
17303                         ConnectSides uint8
17304                         ConnectTo    []Content
17305                         InsideTint   color.NRGBA
17306                         Level        uint8 // Must be < 128.
17307
17308                         Translucent bool // Sunlight is scattered and becomes normal light.
17309                         Transparent bool // Sunlight isn't scattered.
17310                         LightSrc    uint8
17311
17312                         GndContent   bool
17313                         Collides     bool
17314                         Pointable    bool
17315                         Diggable     bool
17316                         Climbable    bool
17317                         Replaceable  bool
17318                         OnRightClick bool
17319
17320                         DmgPerSec int32
17321
17322                         LiquidType   LiquidType
17323                         FlowingAlt   string
17324                         SrcAlt       string
17325                         Viscosity    uint8 // 0-7
17326                         LiqRenewable bool
17327                         FlowRange    uint8
17328                         DrownDmg     uint8
17329                         Floodable    bool
17330
17331                         DrawBox, ColBox, SelBox NodeBox
17332
17333                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17334
17335                         LegacyFaceDir bool
17336                         LegacyMounted bool
17337
17338                         DigPredict string
17339
17340                         MaxLvl uint8
17341
17342                         AlphaUse
17343
17344                         MoveResistance uint8
17345
17346                         LiquidMovePhysics bool
17347                 }))(obj)).FlowingAlt))) > math.MaxUint16 {
17348                         chk(ErrTooLong)
17349                 }
17350                 {
17351                         x := uint16(len(([]byte((*(*(struct {
17352                                 Param0 Content
17353
17354                                 Name   string
17355                                 Groups []Group
17356
17357                                 P1Type   Param1Type
17358                                 P2Type   Param2Type
17359                                 DrawType DrawType
17360
17361                                 Mesh  string
17362                                 Scale float32
17363                                 //mt:const uint8(6)
17364                                 Tiles        [6]TileDef
17365                                 OverlayTiles [6]TileDef
17366                                 //mt:const uint8(6)
17367                                 SpecialTiles [6]TileDef
17368
17369                                 Color   color.NRGBA
17370                                 Palette Texture
17371
17372                                 Waving       WaveType
17373                                 ConnectSides uint8
17374                                 ConnectTo    []Content
17375                                 InsideTint   color.NRGBA
17376                                 Level        uint8 // Must be < 128.
17377
17378                                 Translucent bool // Sunlight is scattered and becomes normal light.
17379                                 Transparent bool // Sunlight isn't scattered.
17380                                 LightSrc    uint8
17381
17382                                 GndContent   bool
17383                                 Collides     bool
17384                                 Pointable    bool
17385                                 Diggable     bool
17386                                 Climbable    bool
17387                                 Replaceable  bool
17388                                 OnRightClick bool
17389
17390                                 DmgPerSec int32
17391
17392                                 LiquidType   LiquidType
17393                                 FlowingAlt   string
17394                                 SrcAlt       string
17395                                 Viscosity    uint8 // 0-7
17396                                 LiqRenewable bool
17397                                 FlowRange    uint8
17398                                 DrownDmg     uint8
17399                                 Floodable    bool
17400
17401                                 DrawBox, ColBox, SelBox NodeBox
17402
17403                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17404
17405                                 LegacyFaceDir bool
17406                                 LegacyMounted bool
17407
17408                                 DigPredict string
17409
17410                                 MaxLvl uint8
17411
17412                                 AlphaUse
17413
17414                                 MoveResistance uint8
17415
17416                                 LiquidMovePhysics bool
17417                         }))(obj)).FlowingAlt))))
17418                         write16(w, uint16(x))
17419                 }
17420                 {
17421                         _, err := w.Write(([]byte((*(*(struct {
17422                                 Param0 Content
17423
17424                                 Name   string
17425                                 Groups []Group
17426
17427                                 P1Type   Param1Type
17428                                 P2Type   Param2Type
17429                                 DrawType DrawType
17430
17431                                 Mesh  string
17432                                 Scale float32
17433                                 //mt:const uint8(6)
17434                                 Tiles        [6]TileDef
17435                                 OverlayTiles [6]TileDef
17436                                 //mt:const uint8(6)
17437                                 SpecialTiles [6]TileDef
17438
17439                                 Color   color.NRGBA
17440                                 Palette Texture
17441
17442                                 Waving       WaveType
17443                                 ConnectSides uint8
17444                                 ConnectTo    []Content
17445                                 InsideTint   color.NRGBA
17446                                 Level        uint8 // Must be < 128.
17447
17448                                 Translucent bool // Sunlight is scattered and becomes normal light.
17449                                 Transparent bool // Sunlight isn't scattered.
17450                                 LightSrc    uint8
17451
17452                                 GndContent   bool
17453                                 Collides     bool
17454                                 Pointable    bool
17455                                 Diggable     bool
17456                                 Climbable    bool
17457                                 Replaceable  bool
17458                                 OnRightClick bool
17459
17460                                 DmgPerSec int32
17461
17462                                 LiquidType   LiquidType
17463                                 FlowingAlt   string
17464                                 SrcAlt       string
17465                                 Viscosity    uint8 // 0-7
17466                                 LiqRenewable bool
17467                                 FlowRange    uint8
17468                                 DrownDmg     uint8
17469                                 Floodable    bool
17470
17471                                 DrawBox, ColBox, SelBox NodeBox
17472
17473                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17474
17475                                 LegacyFaceDir bool
17476                                 LegacyMounted bool
17477
17478                                 DigPredict string
17479
17480                                 MaxLvl uint8
17481
17482                                 AlphaUse
17483
17484                                 MoveResistance uint8
17485
17486                                 LiquidMovePhysics bool
17487                         }))(obj)).FlowingAlt))[:])
17488                         chk(err)
17489                 }
17490                 if len(([]byte((*(*(struct {
17491                         Param0 Content
17492
17493                         Name   string
17494                         Groups []Group
17495
17496                         P1Type   Param1Type
17497                         P2Type   Param2Type
17498                         DrawType DrawType
17499
17500                         Mesh  string
17501                         Scale float32
17502                         //mt:const uint8(6)
17503                         Tiles        [6]TileDef
17504                         OverlayTiles [6]TileDef
17505                         //mt:const uint8(6)
17506                         SpecialTiles [6]TileDef
17507
17508                         Color   color.NRGBA
17509                         Palette Texture
17510
17511                         Waving       WaveType
17512                         ConnectSides uint8
17513                         ConnectTo    []Content
17514                         InsideTint   color.NRGBA
17515                         Level        uint8 // Must be < 128.
17516
17517                         Translucent bool // Sunlight is scattered and becomes normal light.
17518                         Transparent bool // Sunlight isn't scattered.
17519                         LightSrc    uint8
17520
17521                         GndContent   bool
17522                         Collides     bool
17523                         Pointable    bool
17524                         Diggable     bool
17525                         Climbable    bool
17526                         Replaceable  bool
17527                         OnRightClick bool
17528
17529                         DmgPerSec int32
17530
17531                         LiquidType   LiquidType
17532                         FlowingAlt   string
17533                         SrcAlt       string
17534                         Viscosity    uint8 // 0-7
17535                         LiqRenewable bool
17536                         FlowRange    uint8
17537                         DrownDmg     uint8
17538                         Floodable    bool
17539
17540                         DrawBox, ColBox, SelBox NodeBox
17541
17542                         FootstepSnd, DiggingSnd, DugSnd SoundDef
17543
17544                         LegacyFaceDir bool
17545                         LegacyMounted bool
17546
17547                         DigPredict string
17548
17549                         MaxLvl uint8
17550
17551                         AlphaUse
17552
17553                         MoveResistance uint8
17554
17555                         LiquidMovePhysics bool
17556                 }))(obj)).SrcAlt))) > math.MaxUint16 {
17557                         chk(ErrTooLong)
17558                 }
17559                 {
17560                         x := uint16(len(([]byte((*(*(struct {
17561                                 Param0 Content
17562
17563                                 Name   string
17564                                 Groups []Group
17565
17566                                 P1Type   Param1Type
17567                                 P2Type   Param2Type
17568                                 DrawType DrawType
17569
17570                                 Mesh  string
17571                                 Scale float32
17572                                 //mt:const uint8(6)
17573                                 Tiles        [6]TileDef
17574                                 OverlayTiles [6]TileDef
17575                                 //mt:const uint8(6)
17576                                 SpecialTiles [6]TileDef
17577
17578                                 Color   color.NRGBA
17579                                 Palette Texture
17580
17581                                 Waving       WaveType
17582                                 ConnectSides uint8
17583                                 ConnectTo    []Content
17584                                 InsideTint   color.NRGBA
17585                                 Level        uint8 // Must be < 128.
17586
17587                                 Translucent bool // Sunlight is scattered and becomes normal light.
17588                                 Transparent bool // Sunlight isn't scattered.
17589                                 LightSrc    uint8
17590
17591                                 GndContent   bool
17592                                 Collides     bool
17593                                 Pointable    bool
17594                                 Diggable     bool
17595                                 Climbable    bool
17596                                 Replaceable  bool
17597                                 OnRightClick bool
17598
17599                                 DmgPerSec int32
17600
17601                                 LiquidType   LiquidType
17602                                 FlowingAlt   string
17603                                 SrcAlt       string
17604                                 Viscosity    uint8 // 0-7
17605                                 LiqRenewable bool
17606                                 FlowRange    uint8
17607                                 DrownDmg     uint8
17608                                 Floodable    bool
17609
17610                                 DrawBox, ColBox, SelBox NodeBox
17611
17612                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17613
17614                                 LegacyFaceDir bool
17615                                 LegacyMounted bool
17616
17617                                 DigPredict string
17618
17619                                 MaxLvl uint8
17620
17621                                 AlphaUse
17622
17623                                 MoveResistance uint8
17624
17625                                 LiquidMovePhysics bool
17626                         }))(obj)).SrcAlt))))
17627                         write16(w, uint16(x))
17628                 }
17629                 {
17630                         _, err := w.Write(([]byte((*(*(struct {
17631                                 Param0 Content
17632
17633                                 Name   string
17634                                 Groups []Group
17635
17636                                 P1Type   Param1Type
17637                                 P2Type   Param2Type
17638                                 DrawType DrawType
17639
17640                                 Mesh  string
17641                                 Scale float32
17642                                 //mt:const uint8(6)
17643                                 Tiles        [6]TileDef
17644                                 OverlayTiles [6]TileDef
17645                                 //mt:const uint8(6)
17646                                 SpecialTiles [6]TileDef
17647
17648                                 Color   color.NRGBA
17649                                 Palette Texture
17650
17651                                 Waving       WaveType
17652                                 ConnectSides uint8
17653                                 ConnectTo    []Content
17654                                 InsideTint   color.NRGBA
17655                                 Level        uint8 // Must be < 128.
17656
17657                                 Translucent bool // Sunlight is scattered and becomes normal light.
17658                                 Transparent bool // Sunlight isn't scattered.
17659                                 LightSrc    uint8
17660
17661                                 GndContent   bool
17662                                 Collides     bool
17663                                 Pointable    bool
17664                                 Diggable     bool
17665                                 Climbable    bool
17666                                 Replaceable  bool
17667                                 OnRightClick bool
17668
17669                                 DmgPerSec int32
17670
17671                                 LiquidType   LiquidType
17672                                 FlowingAlt   string
17673                                 SrcAlt       string
17674                                 Viscosity    uint8 // 0-7
17675                                 LiqRenewable bool
17676                                 FlowRange    uint8
17677                                 DrownDmg     uint8
17678                                 Floodable    bool
17679
17680                                 DrawBox, ColBox, SelBox NodeBox
17681
17682                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17683
17684                                 LegacyFaceDir bool
17685                                 LegacyMounted bool
17686
17687                                 DigPredict string
17688
17689                                 MaxLvl uint8
17690
17691                                 AlphaUse
17692
17693                                 MoveResistance uint8
17694
17695                                 LiquidMovePhysics bool
17696                         }))(obj)).SrcAlt))[:])
17697                         chk(err)
17698                 }
17699                 {
17700                         x := (*(*(struct {
17701                                 Param0 Content
17702
17703                                 Name   string
17704                                 Groups []Group
17705
17706                                 P1Type   Param1Type
17707                                 P2Type   Param2Type
17708                                 DrawType DrawType
17709
17710                                 Mesh  string
17711                                 Scale float32
17712                                 //mt:const uint8(6)
17713                                 Tiles        [6]TileDef
17714                                 OverlayTiles [6]TileDef
17715                                 //mt:const uint8(6)
17716                                 SpecialTiles [6]TileDef
17717
17718                                 Color   color.NRGBA
17719                                 Palette Texture
17720
17721                                 Waving       WaveType
17722                                 ConnectSides uint8
17723                                 ConnectTo    []Content
17724                                 InsideTint   color.NRGBA
17725                                 Level        uint8 // Must be < 128.
17726
17727                                 Translucent bool // Sunlight is scattered and becomes normal light.
17728                                 Transparent bool // Sunlight isn't scattered.
17729                                 LightSrc    uint8
17730
17731                                 GndContent   bool
17732                                 Collides     bool
17733                                 Pointable    bool
17734                                 Diggable     bool
17735                                 Climbable    bool
17736                                 Replaceable  bool
17737                                 OnRightClick bool
17738
17739                                 DmgPerSec int32
17740
17741                                 LiquidType   LiquidType
17742                                 FlowingAlt   string
17743                                 SrcAlt       string
17744                                 Viscosity    uint8 // 0-7
17745                                 LiqRenewable bool
17746                                 FlowRange    uint8
17747                                 DrownDmg     uint8
17748                                 Floodable    bool
17749
17750                                 DrawBox, ColBox, SelBox NodeBox
17751
17752                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17753
17754                                 LegacyFaceDir bool
17755                                 LegacyMounted bool
17756
17757                                 DigPredict string
17758
17759                                 MaxLvl uint8
17760
17761                                 AlphaUse
17762
17763                                 MoveResistance uint8
17764
17765                                 LiquidMovePhysics bool
17766                         }))(obj)).Viscosity
17767                         write8(w, uint8(x))
17768                 }
17769                 {
17770                         x := (*(*(struct {
17771                                 Param0 Content
17772
17773                                 Name   string
17774                                 Groups []Group
17775
17776                                 P1Type   Param1Type
17777                                 P2Type   Param2Type
17778                                 DrawType DrawType
17779
17780                                 Mesh  string
17781                                 Scale float32
17782                                 //mt:const uint8(6)
17783                                 Tiles        [6]TileDef
17784                                 OverlayTiles [6]TileDef
17785                                 //mt:const uint8(6)
17786                                 SpecialTiles [6]TileDef
17787
17788                                 Color   color.NRGBA
17789                                 Palette Texture
17790
17791                                 Waving       WaveType
17792                                 ConnectSides uint8
17793                                 ConnectTo    []Content
17794                                 InsideTint   color.NRGBA
17795                                 Level        uint8 // Must be < 128.
17796
17797                                 Translucent bool // Sunlight is scattered and becomes normal light.
17798                                 Transparent bool // Sunlight isn't scattered.
17799                                 LightSrc    uint8
17800
17801                                 GndContent   bool
17802                                 Collides     bool
17803                                 Pointable    bool
17804                                 Diggable     bool
17805                                 Climbable    bool
17806                                 Replaceable  bool
17807                                 OnRightClick bool
17808
17809                                 DmgPerSec int32
17810
17811                                 LiquidType   LiquidType
17812                                 FlowingAlt   string
17813                                 SrcAlt       string
17814                                 Viscosity    uint8 // 0-7
17815                                 LiqRenewable bool
17816                                 FlowRange    uint8
17817                                 DrownDmg     uint8
17818                                 Floodable    bool
17819
17820                                 DrawBox, ColBox, SelBox NodeBox
17821
17822                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17823
17824                                 LegacyFaceDir bool
17825                                 LegacyMounted bool
17826
17827                                 DigPredict string
17828
17829                                 MaxLvl uint8
17830
17831                                 AlphaUse
17832
17833                                 MoveResistance uint8
17834
17835                                 LiquidMovePhysics bool
17836                         }))(obj)).LiqRenewable
17837                         if x {
17838                                 write8(w, 1)
17839                         } else {
17840                                 write8(w, 0)
17841                         }
17842                 }
17843                 {
17844                         x := (*(*(struct {
17845                                 Param0 Content
17846
17847                                 Name   string
17848                                 Groups []Group
17849
17850                                 P1Type   Param1Type
17851                                 P2Type   Param2Type
17852                                 DrawType DrawType
17853
17854                                 Mesh  string
17855                                 Scale float32
17856                                 //mt:const uint8(6)
17857                                 Tiles        [6]TileDef
17858                                 OverlayTiles [6]TileDef
17859                                 //mt:const uint8(6)
17860                                 SpecialTiles [6]TileDef
17861
17862                                 Color   color.NRGBA
17863                                 Palette Texture
17864
17865                                 Waving       WaveType
17866                                 ConnectSides uint8
17867                                 ConnectTo    []Content
17868                                 InsideTint   color.NRGBA
17869                                 Level        uint8 // Must be < 128.
17870
17871                                 Translucent bool // Sunlight is scattered and becomes normal light.
17872                                 Transparent bool // Sunlight isn't scattered.
17873                                 LightSrc    uint8
17874
17875                                 GndContent   bool
17876                                 Collides     bool
17877                                 Pointable    bool
17878                                 Diggable     bool
17879                                 Climbable    bool
17880                                 Replaceable  bool
17881                                 OnRightClick bool
17882
17883                                 DmgPerSec int32
17884
17885                                 LiquidType   LiquidType
17886                                 FlowingAlt   string
17887                                 SrcAlt       string
17888                                 Viscosity    uint8 // 0-7
17889                                 LiqRenewable bool
17890                                 FlowRange    uint8
17891                                 DrownDmg     uint8
17892                                 Floodable    bool
17893
17894                                 DrawBox, ColBox, SelBox NodeBox
17895
17896                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17897
17898                                 LegacyFaceDir bool
17899                                 LegacyMounted bool
17900
17901                                 DigPredict string
17902
17903                                 MaxLvl uint8
17904
17905                                 AlphaUse
17906
17907                                 MoveResistance uint8
17908
17909                                 LiquidMovePhysics bool
17910                         }))(obj)).FlowRange
17911                         write8(w, uint8(x))
17912                 }
17913                 {
17914                         x := (*(*(struct {
17915                                 Param0 Content
17916
17917                                 Name   string
17918                                 Groups []Group
17919
17920                                 P1Type   Param1Type
17921                                 P2Type   Param2Type
17922                                 DrawType DrawType
17923
17924                                 Mesh  string
17925                                 Scale float32
17926                                 //mt:const uint8(6)
17927                                 Tiles        [6]TileDef
17928                                 OverlayTiles [6]TileDef
17929                                 //mt:const uint8(6)
17930                                 SpecialTiles [6]TileDef
17931
17932                                 Color   color.NRGBA
17933                                 Palette Texture
17934
17935                                 Waving       WaveType
17936                                 ConnectSides uint8
17937                                 ConnectTo    []Content
17938                                 InsideTint   color.NRGBA
17939                                 Level        uint8 // Must be < 128.
17940
17941                                 Translucent bool // Sunlight is scattered and becomes normal light.
17942                                 Transparent bool // Sunlight isn't scattered.
17943                                 LightSrc    uint8
17944
17945                                 GndContent   bool
17946                                 Collides     bool
17947                                 Pointable    bool
17948                                 Diggable     bool
17949                                 Climbable    bool
17950                                 Replaceable  bool
17951                                 OnRightClick bool
17952
17953                                 DmgPerSec int32
17954
17955                                 LiquidType   LiquidType
17956                                 FlowingAlt   string
17957                                 SrcAlt       string
17958                                 Viscosity    uint8 // 0-7
17959                                 LiqRenewable bool
17960                                 FlowRange    uint8
17961                                 DrownDmg     uint8
17962                                 Floodable    bool
17963
17964                                 DrawBox, ColBox, SelBox NodeBox
17965
17966                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
17967
17968                                 LegacyFaceDir bool
17969                                 LegacyMounted bool
17970
17971                                 DigPredict string
17972
17973                                 MaxLvl uint8
17974
17975                                 AlphaUse
17976
17977                                 MoveResistance uint8
17978
17979                                 LiquidMovePhysics bool
17980                         }))(obj)).DrownDmg
17981                         write8(w, uint8(x))
17982                 }
17983                 {
17984                         x := (*(*(struct {
17985                                 Param0 Content
17986
17987                                 Name   string
17988                                 Groups []Group
17989
17990                                 P1Type   Param1Type
17991                                 P2Type   Param2Type
17992                                 DrawType DrawType
17993
17994                                 Mesh  string
17995                                 Scale float32
17996                                 //mt:const uint8(6)
17997                                 Tiles        [6]TileDef
17998                                 OverlayTiles [6]TileDef
17999                                 //mt:const uint8(6)
18000                                 SpecialTiles [6]TileDef
18001
18002                                 Color   color.NRGBA
18003                                 Palette Texture
18004
18005                                 Waving       WaveType
18006                                 ConnectSides uint8
18007                                 ConnectTo    []Content
18008                                 InsideTint   color.NRGBA
18009                                 Level        uint8 // Must be < 128.
18010
18011                                 Translucent bool // Sunlight is scattered and becomes normal light.
18012                                 Transparent bool // Sunlight isn't scattered.
18013                                 LightSrc    uint8
18014
18015                                 GndContent   bool
18016                                 Collides     bool
18017                                 Pointable    bool
18018                                 Diggable     bool
18019                                 Climbable    bool
18020                                 Replaceable  bool
18021                                 OnRightClick bool
18022
18023                                 DmgPerSec int32
18024
18025                                 LiquidType   LiquidType
18026                                 FlowingAlt   string
18027                                 SrcAlt       string
18028                                 Viscosity    uint8 // 0-7
18029                                 LiqRenewable bool
18030                                 FlowRange    uint8
18031                                 DrownDmg     uint8
18032                                 Floodable    bool
18033
18034                                 DrawBox, ColBox, SelBox NodeBox
18035
18036                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18037
18038                                 LegacyFaceDir bool
18039                                 LegacyMounted bool
18040
18041                                 DigPredict string
18042
18043                                 MaxLvl uint8
18044
18045                                 AlphaUse
18046
18047                                 MoveResistance uint8
18048
18049                                 LiquidMovePhysics bool
18050                         }))(obj)).Floodable
18051                         if x {
18052                                 write8(w, 1)
18053                         } else {
18054                                 write8(w, 0)
18055                         }
18056                 }
18057                 if err := pcall(func() {
18058                         ((*(*(struct {
18059                                 Param0 Content
18060
18061                                 Name   string
18062                                 Groups []Group
18063
18064                                 P1Type   Param1Type
18065                                 P2Type   Param2Type
18066                                 DrawType DrawType
18067
18068                                 Mesh  string
18069                                 Scale float32
18070                                 //mt:const uint8(6)
18071                                 Tiles        [6]TileDef
18072                                 OverlayTiles [6]TileDef
18073                                 //mt:const uint8(6)
18074                                 SpecialTiles [6]TileDef
18075
18076                                 Color   color.NRGBA
18077                                 Palette Texture
18078
18079                                 Waving       WaveType
18080                                 ConnectSides uint8
18081                                 ConnectTo    []Content
18082                                 InsideTint   color.NRGBA
18083                                 Level        uint8 // Must be < 128.
18084
18085                                 Translucent bool // Sunlight is scattered and becomes normal light.
18086                                 Transparent bool // Sunlight isn't scattered.
18087                                 LightSrc    uint8
18088
18089                                 GndContent   bool
18090                                 Collides     bool
18091                                 Pointable    bool
18092                                 Diggable     bool
18093                                 Climbable    bool
18094                                 Replaceable  bool
18095                                 OnRightClick bool
18096
18097                                 DmgPerSec int32
18098
18099                                 LiquidType   LiquidType
18100                                 FlowingAlt   string
18101                                 SrcAlt       string
18102                                 Viscosity    uint8 // 0-7
18103                                 LiqRenewable bool
18104                                 FlowRange    uint8
18105                                 DrownDmg     uint8
18106                                 Floodable    bool
18107
18108                                 DrawBox, ColBox, SelBox NodeBox
18109
18110                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18111
18112                                 LegacyFaceDir bool
18113                                 LegacyMounted bool
18114
18115                                 DigPredict string
18116
18117                                 MaxLvl uint8
18118
18119                                 AlphaUse
18120
18121                                 MoveResistance uint8
18122
18123                                 LiquidMovePhysics bool
18124                         }))(obj)).DrawBox).serialize(w)
18125                 }); err != nil {
18126                         if err == io.EOF {
18127                                 chk(io.EOF)
18128                         }
18129                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18130                 }
18131                 if err := pcall(func() {
18132                         ((*(*(struct {
18133                                 Param0 Content
18134
18135                                 Name   string
18136                                 Groups []Group
18137
18138                                 P1Type   Param1Type
18139                                 P2Type   Param2Type
18140                                 DrawType DrawType
18141
18142                                 Mesh  string
18143                                 Scale float32
18144                                 //mt:const uint8(6)
18145                                 Tiles        [6]TileDef
18146                                 OverlayTiles [6]TileDef
18147                                 //mt:const uint8(6)
18148                                 SpecialTiles [6]TileDef
18149
18150                                 Color   color.NRGBA
18151                                 Palette Texture
18152
18153                                 Waving       WaveType
18154                                 ConnectSides uint8
18155                                 ConnectTo    []Content
18156                                 InsideTint   color.NRGBA
18157                                 Level        uint8 // Must be < 128.
18158
18159                                 Translucent bool // Sunlight is scattered and becomes normal light.
18160                                 Transparent bool // Sunlight isn't scattered.
18161                                 LightSrc    uint8
18162
18163                                 GndContent   bool
18164                                 Collides     bool
18165                                 Pointable    bool
18166                                 Diggable     bool
18167                                 Climbable    bool
18168                                 Replaceable  bool
18169                                 OnRightClick bool
18170
18171                                 DmgPerSec int32
18172
18173                                 LiquidType   LiquidType
18174                                 FlowingAlt   string
18175                                 SrcAlt       string
18176                                 Viscosity    uint8 // 0-7
18177                                 LiqRenewable bool
18178                                 FlowRange    uint8
18179                                 DrownDmg     uint8
18180                                 Floodable    bool
18181
18182                                 DrawBox, ColBox, SelBox NodeBox
18183
18184                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18185
18186                                 LegacyFaceDir bool
18187                                 LegacyMounted bool
18188
18189                                 DigPredict string
18190
18191                                 MaxLvl uint8
18192
18193                                 AlphaUse
18194
18195                                 MoveResistance uint8
18196
18197                                 LiquidMovePhysics bool
18198                         }))(obj)).ColBox).serialize(w)
18199                 }); err != nil {
18200                         if err == io.EOF {
18201                                 chk(io.EOF)
18202                         }
18203                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18204                 }
18205                 if err := pcall(func() {
18206                         ((*(*(struct {
18207                                 Param0 Content
18208
18209                                 Name   string
18210                                 Groups []Group
18211
18212                                 P1Type   Param1Type
18213                                 P2Type   Param2Type
18214                                 DrawType DrawType
18215
18216                                 Mesh  string
18217                                 Scale float32
18218                                 //mt:const uint8(6)
18219                                 Tiles        [6]TileDef
18220                                 OverlayTiles [6]TileDef
18221                                 //mt:const uint8(6)
18222                                 SpecialTiles [6]TileDef
18223
18224                                 Color   color.NRGBA
18225                                 Palette Texture
18226
18227                                 Waving       WaveType
18228                                 ConnectSides uint8
18229                                 ConnectTo    []Content
18230                                 InsideTint   color.NRGBA
18231                                 Level        uint8 // Must be < 128.
18232
18233                                 Translucent bool // Sunlight is scattered and becomes normal light.
18234                                 Transparent bool // Sunlight isn't scattered.
18235                                 LightSrc    uint8
18236
18237                                 GndContent   bool
18238                                 Collides     bool
18239                                 Pointable    bool
18240                                 Diggable     bool
18241                                 Climbable    bool
18242                                 Replaceable  bool
18243                                 OnRightClick bool
18244
18245                                 DmgPerSec int32
18246
18247                                 LiquidType   LiquidType
18248                                 FlowingAlt   string
18249                                 SrcAlt       string
18250                                 Viscosity    uint8 // 0-7
18251                                 LiqRenewable bool
18252                                 FlowRange    uint8
18253                                 DrownDmg     uint8
18254                                 Floodable    bool
18255
18256                                 DrawBox, ColBox, SelBox NodeBox
18257
18258                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18259
18260                                 LegacyFaceDir bool
18261                                 LegacyMounted bool
18262
18263                                 DigPredict string
18264
18265                                 MaxLvl uint8
18266
18267                                 AlphaUse
18268
18269                                 MoveResistance uint8
18270
18271                                 LiquidMovePhysics bool
18272                         }))(obj)).SelBox).serialize(w)
18273                 }); err != nil {
18274                         if err == io.EOF {
18275                                 chk(io.EOF)
18276                         }
18277                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
18278                 }
18279                 if err := pcall(func() {
18280                         ((*(*(struct {
18281                                 Param0 Content
18282
18283                                 Name   string
18284                                 Groups []Group
18285
18286                                 P1Type   Param1Type
18287                                 P2Type   Param2Type
18288                                 DrawType DrawType
18289
18290                                 Mesh  string
18291                                 Scale float32
18292                                 //mt:const uint8(6)
18293                                 Tiles        [6]TileDef
18294                                 OverlayTiles [6]TileDef
18295                                 //mt:const uint8(6)
18296                                 SpecialTiles [6]TileDef
18297
18298                                 Color   color.NRGBA
18299                                 Palette Texture
18300
18301                                 Waving       WaveType
18302                                 ConnectSides uint8
18303                                 ConnectTo    []Content
18304                                 InsideTint   color.NRGBA
18305                                 Level        uint8 // Must be < 128.
18306
18307                                 Translucent bool // Sunlight is scattered and becomes normal light.
18308                                 Transparent bool // Sunlight isn't scattered.
18309                                 LightSrc    uint8
18310
18311                                 GndContent   bool
18312                                 Collides     bool
18313                                 Pointable    bool
18314                                 Diggable     bool
18315                                 Climbable    bool
18316                                 Replaceable  bool
18317                                 OnRightClick bool
18318
18319                                 DmgPerSec int32
18320
18321                                 LiquidType   LiquidType
18322                                 FlowingAlt   string
18323                                 SrcAlt       string
18324                                 Viscosity    uint8 // 0-7
18325                                 LiqRenewable bool
18326                                 FlowRange    uint8
18327                                 DrownDmg     uint8
18328                                 Floodable    bool
18329
18330                                 DrawBox, ColBox, SelBox NodeBox
18331
18332                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18333
18334                                 LegacyFaceDir bool
18335                                 LegacyMounted bool
18336
18337                                 DigPredict string
18338
18339                                 MaxLvl uint8
18340
18341                                 AlphaUse
18342
18343                                 MoveResistance uint8
18344
18345                                 LiquidMovePhysics bool
18346                         }))(obj)).FootstepSnd).serialize(w)
18347                 }); err != nil {
18348                         if err == io.EOF {
18349                                 chk(io.EOF)
18350                         }
18351                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18352                 }
18353                 if err := pcall(func() {
18354                         ((*(*(struct {
18355                                 Param0 Content
18356
18357                                 Name   string
18358                                 Groups []Group
18359
18360                                 P1Type   Param1Type
18361                                 P2Type   Param2Type
18362                                 DrawType DrawType
18363
18364                                 Mesh  string
18365                                 Scale float32
18366                                 //mt:const uint8(6)
18367                                 Tiles        [6]TileDef
18368                                 OverlayTiles [6]TileDef
18369                                 //mt:const uint8(6)
18370                                 SpecialTiles [6]TileDef
18371
18372                                 Color   color.NRGBA
18373                                 Palette Texture
18374
18375                                 Waving       WaveType
18376                                 ConnectSides uint8
18377                                 ConnectTo    []Content
18378                                 InsideTint   color.NRGBA
18379                                 Level        uint8 // Must be < 128.
18380
18381                                 Translucent bool // Sunlight is scattered and becomes normal light.
18382                                 Transparent bool // Sunlight isn't scattered.
18383                                 LightSrc    uint8
18384
18385                                 GndContent   bool
18386                                 Collides     bool
18387                                 Pointable    bool
18388                                 Diggable     bool
18389                                 Climbable    bool
18390                                 Replaceable  bool
18391                                 OnRightClick bool
18392
18393                                 DmgPerSec int32
18394
18395                                 LiquidType   LiquidType
18396                                 FlowingAlt   string
18397                                 SrcAlt       string
18398                                 Viscosity    uint8 // 0-7
18399                                 LiqRenewable bool
18400                                 FlowRange    uint8
18401                                 DrownDmg     uint8
18402                                 Floodable    bool
18403
18404                                 DrawBox, ColBox, SelBox NodeBox
18405
18406                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18407
18408                                 LegacyFaceDir bool
18409                                 LegacyMounted bool
18410
18411                                 DigPredict string
18412
18413                                 MaxLvl uint8
18414
18415                                 AlphaUse
18416
18417                                 MoveResistance uint8
18418
18419                                 LiquidMovePhysics bool
18420                         }))(obj)).DiggingSnd).serialize(w)
18421                 }); err != nil {
18422                         if err == io.EOF {
18423                                 chk(io.EOF)
18424                         }
18425                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18426                 }
18427                 if err := pcall(func() {
18428                         ((*(*(struct {
18429                                 Param0 Content
18430
18431                                 Name   string
18432                                 Groups []Group
18433
18434                                 P1Type   Param1Type
18435                                 P2Type   Param2Type
18436                                 DrawType DrawType
18437
18438                                 Mesh  string
18439                                 Scale float32
18440                                 //mt:const uint8(6)
18441                                 Tiles        [6]TileDef
18442                                 OverlayTiles [6]TileDef
18443                                 //mt:const uint8(6)
18444                                 SpecialTiles [6]TileDef
18445
18446                                 Color   color.NRGBA
18447                                 Palette Texture
18448
18449                                 Waving       WaveType
18450                                 ConnectSides uint8
18451                                 ConnectTo    []Content
18452                                 InsideTint   color.NRGBA
18453                                 Level        uint8 // Must be < 128.
18454
18455                                 Translucent bool // Sunlight is scattered and becomes normal light.
18456                                 Transparent bool // Sunlight isn't scattered.
18457                                 LightSrc    uint8
18458
18459                                 GndContent   bool
18460                                 Collides     bool
18461                                 Pointable    bool
18462                                 Diggable     bool
18463                                 Climbable    bool
18464                                 Replaceable  bool
18465                                 OnRightClick bool
18466
18467                                 DmgPerSec int32
18468
18469                                 LiquidType   LiquidType
18470                                 FlowingAlt   string
18471                                 SrcAlt       string
18472                                 Viscosity    uint8 // 0-7
18473                                 LiqRenewable bool
18474                                 FlowRange    uint8
18475                                 DrownDmg     uint8
18476                                 Floodable    bool
18477
18478                                 DrawBox, ColBox, SelBox NodeBox
18479
18480                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18481
18482                                 LegacyFaceDir bool
18483                                 LegacyMounted bool
18484
18485                                 DigPredict string
18486
18487                                 MaxLvl uint8
18488
18489                                 AlphaUse
18490
18491                                 MoveResistance uint8
18492
18493                                 LiquidMovePhysics bool
18494                         }))(obj)).DugSnd).serialize(w)
18495                 }); err != nil {
18496                         if err == io.EOF {
18497                                 chk(io.EOF)
18498                         }
18499                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
18500                 }
18501                 {
18502                         x := (*(*(struct {
18503                                 Param0 Content
18504
18505                                 Name   string
18506                                 Groups []Group
18507
18508                                 P1Type   Param1Type
18509                                 P2Type   Param2Type
18510                                 DrawType DrawType
18511
18512                                 Mesh  string
18513                                 Scale float32
18514                                 //mt:const uint8(6)
18515                                 Tiles        [6]TileDef
18516                                 OverlayTiles [6]TileDef
18517                                 //mt:const uint8(6)
18518                                 SpecialTiles [6]TileDef
18519
18520                                 Color   color.NRGBA
18521                                 Palette Texture
18522
18523                                 Waving       WaveType
18524                                 ConnectSides uint8
18525                                 ConnectTo    []Content
18526                                 InsideTint   color.NRGBA
18527                                 Level        uint8 // Must be < 128.
18528
18529                                 Translucent bool // Sunlight is scattered and becomes normal light.
18530                                 Transparent bool // Sunlight isn't scattered.
18531                                 LightSrc    uint8
18532
18533                                 GndContent   bool
18534                                 Collides     bool
18535                                 Pointable    bool
18536                                 Diggable     bool
18537                                 Climbable    bool
18538                                 Replaceable  bool
18539                                 OnRightClick bool
18540
18541                                 DmgPerSec int32
18542
18543                                 LiquidType   LiquidType
18544                                 FlowingAlt   string
18545                                 SrcAlt       string
18546                                 Viscosity    uint8 // 0-7
18547                                 LiqRenewable bool
18548                                 FlowRange    uint8
18549                                 DrownDmg     uint8
18550                                 Floodable    bool
18551
18552                                 DrawBox, ColBox, SelBox NodeBox
18553
18554                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18555
18556                                 LegacyFaceDir bool
18557                                 LegacyMounted bool
18558
18559                                 DigPredict string
18560
18561                                 MaxLvl uint8
18562
18563                                 AlphaUse
18564
18565                                 MoveResistance uint8
18566
18567                                 LiquidMovePhysics bool
18568                         }))(obj)).LegacyFaceDir
18569                         if x {
18570                                 write8(w, 1)
18571                         } else {
18572                                 write8(w, 0)
18573                         }
18574                 }
18575                 {
18576                         x := (*(*(struct {
18577                                 Param0 Content
18578
18579                                 Name   string
18580                                 Groups []Group
18581
18582                                 P1Type   Param1Type
18583                                 P2Type   Param2Type
18584                                 DrawType DrawType
18585
18586                                 Mesh  string
18587                                 Scale float32
18588                                 //mt:const uint8(6)
18589                                 Tiles        [6]TileDef
18590                                 OverlayTiles [6]TileDef
18591                                 //mt:const uint8(6)
18592                                 SpecialTiles [6]TileDef
18593
18594                                 Color   color.NRGBA
18595                                 Palette Texture
18596
18597                                 Waving       WaveType
18598                                 ConnectSides uint8
18599                                 ConnectTo    []Content
18600                                 InsideTint   color.NRGBA
18601                                 Level        uint8 // Must be < 128.
18602
18603                                 Translucent bool // Sunlight is scattered and becomes normal light.
18604                                 Transparent bool // Sunlight isn't scattered.
18605                                 LightSrc    uint8
18606
18607                                 GndContent   bool
18608                                 Collides     bool
18609                                 Pointable    bool
18610                                 Diggable     bool
18611                                 Climbable    bool
18612                                 Replaceable  bool
18613                                 OnRightClick bool
18614
18615                                 DmgPerSec int32
18616
18617                                 LiquidType   LiquidType
18618                                 FlowingAlt   string
18619                                 SrcAlt       string
18620                                 Viscosity    uint8 // 0-7
18621                                 LiqRenewable bool
18622                                 FlowRange    uint8
18623                                 DrownDmg     uint8
18624                                 Floodable    bool
18625
18626                                 DrawBox, ColBox, SelBox NodeBox
18627
18628                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18629
18630                                 LegacyFaceDir bool
18631                                 LegacyMounted bool
18632
18633                                 DigPredict string
18634
18635                                 MaxLvl uint8
18636
18637                                 AlphaUse
18638
18639                                 MoveResistance uint8
18640
18641                                 LiquidMovePhysics bool
18642                         }))(obj)).LegacyMounted
18643                         if x {
18644                                 write8(w, 1)
18645                         } else {
18646                                 write8(w, 0)
18647                         }
18648                 }
18649                 if len(([]byte((*(*(struct {
18650                         Param0 Content
18651
18652                         Name   string
18653                         Groups []Group
18654
18655                         P1Type   Param1Type
18656                         P2Type   Param2Type
18657                         DrawType DrawType
18658
18659                         Mesh  string
18660                         Scale float32
18661                         //mt:const uint8(6)
18662                         Tiles        [6]TileDef
18663                         OverlayTiles [6]TileDef
18664                         //mt:const uint8(6)
18665                         SpecialTiles [6]TileDef
18666
18667                         Color   color.NRGBA
18668                         Palette Texture
18669
18670                         Waving       WaveType
18671                         ConnectSides uint8
18672                         ConnectTo    []Content
18673                         InsideTint   color.NRGBA
18674                         Level        uint8 // Must be < 128.
18675
18676                         Translucent bool // Sunlight is scattered and becomes normal light.
18677                         Transparent bool // Sunlight isn't scattered.
18678                         LightSrc    uint8
18679
18680                         GndContent   bool
18681                         Collides     bool
18682                         Pointable    bool
18683                         Diggable     bool
18684                         Climbable    bool
18685                         Replaceable  bool
18686                         OnRightClick bool
18687
18688                         DmgPerSec int32
18689
18690                         LiquidType   LiquidType
18691                         FlowingAlt   string
18692                         SrcAlt       string
18693                         Viscosity    uint8 // 0-7
18694                         LiqRenewable bool
18695                         FlowRange    uint8
18696                         DrownDmg     uint8
18697                         Floodable    bool
18698
18699                         DrawBox, ColBox, SelBox NodeBox
18700
18701                         FootstepSnd, DiggingSnd, DugSnd SoundDef
18702
18703                         LegacyFaceDir bool
18704                         LegacyMounted bool
18705
18706                         DigPredict string
18707
18708                         MaxLvl uint8
18709
18710                         AlphaUse
18711
18712                         MoveResistance uint8
18713
18714                         LiquidMovePhysics bool
18715                 }))(obj)).DigPredict))) > math.MaxUint16 {
18716                         chk(ErrTooLong)
18717                 }
18718                 {
18719                         x := uint16(len(([]byte((*(*(struct {
18720                                 Param0 Content
18721
18722                                 Name   string
18723                                 Groups []Group
18724
18725                                 P1Type   Param1Type
18726                                 P2Type   Param2Type
18727                                 DrawType DrawType
18728
18729                                 Mesh  string
18730                                 Scale float32
18731                                 //mt:const uint8(6)
18732                                 Tiles        [6]TileDef
18733                                 OverlayTiles [6]TileDef
18734                                 //mt:const uint8(6)
18735                                 SpecialTiles [6]TileDef
18736
18737                                 Color   color.NRGBA
18738                                 Palette Texture
18739
18740                                 Waving       WaveType
18741                                 ConnectSides uint8
18742                                 ConnectTo    []Content
18743                                 InsideTint   color.NRGBA
18744                                 Level        uint8 // Must be < 128.
18745
18746                                 Translucent bool // Sunlight is scattered and becomes normal light.
18747                                 Transparent bool // Sunlight isn't scattered.
18748                                 LightSrc    uint8
18749
18750                                 GndContent   bool
18751                                 Collides     bool
18752                                 Pointable    bool
18753                                 Diggable     bool
18754                                 Climbable    bool
18755                                 Replaceable  bool
18756                                 OnRightClick bool
18757
18758                                 DmgPerSec int32
18759
18760                                 LiquidType   LiquidType
18761                                 FlowingAlt   string
18762                                 SrcAlt       string
18763                                 Viscosity    uint8 // 0-7
18764                                 LiqRenewable bool
18765                                 FlowRange    uint8
18766                                 DrownDmg     uint8
18767                                 Floodable    bool
18768
18769                                 DrawBox, ColBox, SelBox NodeBox
18770
18771                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18772
18773                                 LegacyFaceDir bool
18774                                 LegacyMounted bool
18775
18776                                 DigPredict string
18777
18778                                 MaxLvl uint8
18779
18780                                 AlphaUse
18781
18782                                 MoveResistance uint8
18783
18784                                 LiquidMovePhysics bool
18785                         }))(obj)).DigPredict))))
18786                         write16(w, uint16(x))
18787                 }
18788                 {
18789                         _, err := w.Write(([]byte((*(*(struct {
18790                                 Param0 Content
18791
18792                                 Name   string
18793                                 Groups []Group
18794
18795                                 P1Type   Param1Type
18796                                 P2Type   Param2Type
18797                                 DrawType DrawType
18798
18799                                 Mesh  string
18800                                 Scale float32
18801                                 //mt:const uint8(6)
18802                                 Tiles        [6]TileDef
18803                                 OverlayTiles [6]TileDef
18804                                 //mt:const uint8(6)
18805                                 SpecialTiles [6]TileDef
18806
18807                                 Color   color.NRGBA
18808                                 Palette Texture
18809
18810                                 Waving       WaveType
18811                                 ConnectSides uint8
18812                                 ConnectTo    []Content
18813                                 InsideTint   color.NRGBA
18814                                 Level        uint8 // Must be < 128.
18815
18816                                 Translucent bool // Sunlight is scattered and becomes normal light.
18817                                 Transparent bool // Sunlight isn't scattered.
18818                                 LightSrc    uint8
18819
18820                                 GndContent   bool
18821                                 Collides     bool
18822                                 Pointable    bool
18823                                 Diggable     bool
18824                                 Climbable    bool
18825                                 Replaceable  bool
18826                                 OnRightClick bool
18827
18828                                 DmgPerSec int32
18829
18830                                 LiquidType   LiquidType
18831                                 FlowingAlt   string
18832                                 SrcAlt       string
18833                                 Viscosity    uint8 // 0-7
18834                                 LiqRenewable bool
18835                                 FlowRange    uint8
18836                                 DrownDmg     uint8
18837                                 Floodable    bool
18838
18839                                 DrawBox, ColBox, SelBox NodeBox
18840
18841                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18842
18843                                 LegacyFaceDir bool
18844                                 LegacyMounted bool
18845
18846                                 DigPredict string
18847
18848                                 MaxLvl uint8
18849
18850                                 AlphaUse
18851
18852                                 MoveResistance uint8
18853
18854                                 LiquidMovePhysics bool
18855                         }))(obj)).DigPredict))[:])
18856                         chk(err)
18857                 }
18858                 {
18859                         x := (*(*(struct {
18860                                 Param0 Content
18861
18862                                 Name   string
18863                                 Groups []Group
18864
18865                                 P1Type   Param1Type
18866                                 P2Type   Param2Type
18867                                 DrawType DrawType
18868
18869                                 Mesh  string
18870                                 Scale float32
18871                                 //mt:const uint8(6)
18872                                 Tiles        [6]TileDef
18873                                 OverlayTiles [6]TileDef
18874                                 //mt:const uint8(6)
18875                                 SpecialTiles [6]TileDef
18876
18877                                 Color   color.NRGBA
18878                                 Palette Texture
18879
18880                                 Waving       WaveType
18881                                 ConnectSides uint8
18882                                 ConnectTo    []Content
18883                                 InsideTint   color.NRGBA
18884                                 Level        uint8 // Must be < 128.
18885
18886                                 Translucent bool // Sunlight is scattered and becomes normal light.
18887                                 Transparent bool // Sunlight isn't scattered.
18888                                 LightSrc    uint8
18889
18890                                 GndContent   bool
18891                                 Collides     bool
18892                                 Pointable    bool
18893                                 Diggable     bool
18894                                 Climbable    bool
18895                                 Replaceable  bool
18896                                 OnRightClick bool
18897
18898                                 DmgPerSec int32
18899
18900                                 LiquidType   LiquidType
18901                                 FlowingAlt   string
18902                                 SrcAlt       string
18903                                 Viscosity    uint8 // 0-7
18904                                 LiqRenewable bool
18905                                 FlowRange    uint8
18906                                 DrownDmg     uint8
18907                                 Floodable    bool
18908
18909                                 DrawBox, ColBox, SelBox NodeBox
18910
18911                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18912
18913                                 LegacyFaceDir bool
18914                                 LegacyMounted bool
18915
18916                                 DigPredict string
18917
18918                                 MaxLvl uint8
18919
18920                                 AlphaUse
18921
18922                                 MoveResistance uint8
18923
18924                                 LiquidMovePhysics bool
18925                         }))(obj)).MaxLvl
18926                         write8(w, uint8(x))
18927                 }
18928                 if err := pcall(func() {
18929                         ((*(*(struct {
18930                                 Param0 Content
18931
18932                                 Name   string
18933                                 Groups []Group
18934
18935                                 P1Type   Param1Type
18936                                 P2Type   Param2Type
18937                                 DrawType DrawType
18938
18939                                 Mesh  string
18940                                 Scale float32
18941                                 //mt:const uint8(6)
18942                                 Tiles        [6]TileDef
18943                                 OverlayTiles [6]TileDef
18944                                 //mt:const uint8(6)
18945                                 SpecialTiles [6]TileDef
18946
18947                                 Color   color.NRGBA
18948                                 Palette Texture
18949
18950                                 Waving       WaveType
18951                                 ConnectSides uint8
18952                                 ConnectTo    []Content
18953                                 InsideTint   color.NRGBA
18954                                 Level        uint8 // Must be < 128.
18955
18956                                 Translucent bool // Sunlight is scattered and becomes normal light.
18957                                 Transparent bool // Sunlight isn't scattered.
18958                                 LightSrc    uint8
18959
18960                                 GndContent   bool
18961                                 Collides     bool
18962                                 Pointable    bool
18963                                 Diggable     bool
18964                                 Climbable    bool
18965                                 Replaceable  bool
18966                                 OnRightClick bool
18967
18968                                 DmgPerSec int32
18969
18970                                 LiquidType   LiquidType
18971                                 FlowingAlt   string
18972                                 SrcAlt       string
18973                                 Viscosity    uint8 // 0-7
18974                                 LiqRenewable bool
18975                                 FlowRange    uint8
18976                                 DrownDmg     uint8
18977                                 Floodable    bool
18978
18979                                 DrawBox, ColBox, SelBox NodeBox
18980
18981                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
18982
18983                                 LegacyFaceDir bool
18984                                 LegacyMounted bool
18985
18986                                 DigPredict string
18987
18988                                 MaxLvl uint8
18989
18990                                 AlphaUse
18991
18992                                 MoveResistance uint8
18993
18994                                 LiquidMovePhysics bool
18995                         }))(obj)).AlphaUse).serialize(w)
18996                 }); err != nil {
18997                         if err == io.EOF {
18998                                 chk(io.EOF)
18999                         }
19000                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlphaUse", err))
19001                 }
19002                 {
19003                         x := (*(*(struct {
19004                                 Param0 Content
19005
19006                                 Name   string
19007                                 Groups []Group
19008
19009                                 P1Type   Param1Type
19010                                 P2Type   Param2Type
19011                                 DrawType DrawType
19012
19013                                 Mesh  string
19014                                 Scale float32
19015                                 //mt:const uint8(6)
19016                                 Tiles        [6]TileDef
19017                                 OverlayTiles [6]TileDef
19018                                 //mt:const uint8(6)
19019                                 SpecialTiles [6]TileDef
19020
19021                                 Color   color.NRGBA
19022                                 Palette Texture
19023
19024                                 Waving       WaveType
19025                                 ConnectSides uint8
19026                                 ConnectTo    []Content
19027                                 InsideTint   color.NRGBA
19028                                 Level        uint8 // Must be < 128.
19029
19030                                 Translucent bool // Sunlight is scattered and becomes normal light.
19031                                 Transparent bool // Sunlight isn't scattered.
19032                                 LightSrc    uint8
19033
19034                                 GndContent   bool
19035                                 Collides     bool
19036                                 Pointable    bool
19037                                 Diggable     bool
19038                                 Climbable    bool
19039                                 Replaceable  bool
19040                                 OnRightClick bool
19041
19042                                 DmgPerSec int32
19043
19044                                 LiquidType   LiquidType
19045                                 FlowingAlt   string
19046                                 SrcAlt       string
19047                                 Viscosity    uint8 // 0-7
19048                                 LiqRenewable bool
19049                                 FlowRange    uint8
19050                                 DrownDmg     uint8
19051                                 Floodable    bool
19052
19053                                 DrawBox, ColBox, SelBox NodeBox
19054
19055                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19056
19057                                 LegacyFaceDir bool
19058                                 LegacyMounted bool
19059
19060                                 DigPredict string
19061
19062                                 MaxLvl uint8
19063
19064                                 AlphaUse
19065
19066                                 MoveResistance uint8
19067
19068                                 LiquidMovePhysics bool
19069                         }))(obj)).MoveResistance
19070                         write8(w, uint8(x))
19071                 }
19072                 {
19073                         x := (*(*(struct {
19074                                 Param0 Content
19075
19076                                 Name   string
19077                                 Groups []Group
19078
19079                                 P1Type   Param1Type
19080                                 P2Type   Param2Type
19081                                 DrawType DrawType
19082
19083                                 Mesh  string
19084                                 Scale float32
19085                                 //mt:const uint8(6)
19086                                 Tiles        [6]TileDef
19087                                 OverlayTiles [6]TileDef
19088                                 //mt:const uint8(6)
19089                                 SpecialTiles [6]TileDef
19090
19091                                 Color   color.NRGBA
19092                                 Palette Texture
19093
19094                                 Waving       WaveType
19095                                 ConnectSides uint8
19096                                 ConnectTo    []Content
19097                                 InsideTint   color.NRGBA
19098                                 Level        uint8 // Must be < 128.
19099
19100                                 Translucent bool // Sunlight is scattered and becomes normal light.
19101                                 Transparent bool // Sunlight isn't scattered.
19102                                 LightSrc    uint8
19103
19104                                 GndContent   bool
19105                                 Collides     bool
19106                                 Pointable    bool
19107                                 Diggable     bool
19108                                 Climbable    bool
19109                                 Replaceable  bool
19110                                 OnRightClick bool
19111
19112                                 DmgPerSec int32
19113
19114                                 LiquidType   LiquidType
19115                                 FlowingAlt   string
19116                                 SrcAlt       string
19117                                 Viscosity    uint8 // 0-7
19118                                 LiqRenewable bool
19119                                 FlowRange    uint8
19120                                 DrownDmg     uint8
19121                                 Floodable    bool
19122
19123                                 DrawBox, ColBox, SelBox NodeBox
19124
19125                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19126
19127                                 LegacyFaceDir bool
19128                                 LegacyMounted bool
19129
19130                                 DigPredict string
19131
19132                                 MaxLvl uint8
19133
19134                                 AlphaUse
19135
19136                                 MoveResistance uint8
19137
19138                                 LiquidMovePhysics bool
19139                         }))(obj)).LiquidMovePhysics
19140                         if x {
19141                                 write8(w, 1)
19142                         } else {
19143                                 write8(w, 0)
19144                         }
19145                 }
19146                 {
19147                         buf := w
19148                         w := ow
19149                         if len((buf.Bytes())) > math.MaxUint16 {
19150                                 chk(ErrTooLong)
19151                         }
19152                         {
19153                                 x := uint16(len((buf.Bytes())))
19154                                 write16(w, uint16(x))
19155                         }
19156                         {
19157                                 _, err := w.Write((buf.Bytes())[:])
19158                                 chk(err)
19159                         }
19160                 }
19161         }
19162 }
19163
19164 func (obj *NodeDef) deserialize(r io.Reader) {
19165         if err := pcall(func() {
19166                 ((*(*(struct {
19167                         Param0 Content
19168
19169                         Name   string
19170                         Groups []Group
19171
19172                         P1Type   Param1Type
19173                         P2Type   Param2Type
19174                         DrawType DrawType
19175
19176                         Mesh  string
19177                         Scale float32
19178                         //mt:const uint8(6)
19179                         Tiles        [6]TileDef
19180                         OverlayTiles [6]TileDef
19181                         //mt:const uint8(6)
19182                         SpecialTiles [6]TileDef
19183
19184                         Color   color.NRGBA
19185                         Palette Texture
19186
19187                         Waving       WaveType
19188                         ConnectSides uint8
19189                         ConnectTo    []Content
19190                         InsideTint   color.NRGBA
19191                         Level        uint8 // Must be < 128.
19192
19193                         Translucent bool // Sunlight is scattered and becomes normal light.
19194                         Transparent bool // Sunlight isn't scattered.
19195                         LightSrc    uint8
19196
19197                         GndContent   bool
19198                         Collides     bool
19199                         Pointable    bool
19200                         Diggable     bool
19201                         Climbable    bool
19202                         Replaceable  bool
19203                         OnRightClick bool
19204
19205                         DmgPerSec int32
19206
19207                         LiquidType   LiquidType
19208                         FlowingAlt   string
19209                         SrcAlt       string
19210                         Viscosity    uint8 // 0-7
19211                         LiqRenewable bool
19212                         FlowRange    uint8
19213                         DrownDmg     uint8
19214                         Floodable    bool
19215
19216                         DrawBox, ColBox, SelBox NodeBox
19217
19218                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19219
19220                         LegacyFaceDir bool
19221                         LegacyMounted bool
19222
19223                         DigPredict string
19224
19225                         MaxLvl uint8
19226
19227                         AlphaUse
19228
19229                         MoveResistance uint8
19230
19231                         LiquidMovePhysics bool
19232                 }))(obj)).Param0).deserialize(r)
19233         }); err != nil {
19234                 if err == io.EOF {
19235                         chk(io.EOF)
19236                 }
19237                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
19238         }
19239         {
19240                 var n uint16
19241                 {
19242                         p := &n
19243                         *p = read16(r)
19244                 }
19245                 r := &io.LimitedReader{R: r, N: int64(n)}
19246                 {
19247                         var local246 uint8
19248                         local247 := uint8(13)
19249                         {
19250                                 p := &local246
19251                                 *p = read8(r)
19252                         }
19253                         if local246 != local247 {
19254                                 chk(fmt.Errorf("const %v: %v", "uint8(13)", local246))
19255                         }
19256                 }
19257                 var local248 []uint8
19258                 var local249 uint16
19259                 {
19260                         p := &local249
19261                         *p = read16(r)
19262                 }
19263                 (local248) = make([]uint8, local249)
19264                 {
19265                         _, err := io.ReadFull(r, (local248)[:])
19266                         chk(err)
19267                 }
19268                 ((*(*(struct {
19269                         Param0 Content
19270
19271                         Name   string
19272                         Groups []Group
19273
19274                         P1Type   Param1Type
19275                         P2Type   Param2Type
19276                         DrawType DrawType
19277
19278                         Mesh  string
19279                         Scale float32
19280                         //mt:const uint8(6)
19281                         Tiles        [6]TileDef
19282                         OverlayTiles [6]TileDef
19283                         //mt:const uint8(6)
19284                         SpecialTiles [6]TileDef
19285
19286                         Color   color.NRGBA
19287                         Palette Texture
19288
19289                         Waving       WaveType
19290                         ConnectSides uint8
19291                         ConnectTo    []Content
19292                         InsideTint   color.NRGBA
19293                         Level        uint8 // Must be < 128.
19294
19295                         Translucent bool // Sunlight is scattered and becomes normal light.
19296                         Transparent bool // Sunlight isn't scattered.
19297                         LightSrc    uint8
19298
19299                         GndContent   bool
19300                         Collides     bool
19301                         Pointable    bool
19302                         Diggable     bool
19303                         Climbable    bool
19304                         Replaceable  bool
19305                         OnRightClick bool
19306
19307                         DmgPerSec int32
19308
19309                         LiquidType   LiquidType
19310                         FlowingAlt   string
19311                         SrcAlt       string
19312                         Viscosity    uint8 // 0-7
19313                         LiqRenewable bool
19314                         FlowRange    uint8
19315                         DrownDmg     uint8
19316                         Floodable    bool
19317
19318                         DrawBox, ColBox, SelBox NodeBox
19319
19320                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19321
19322                         LegacyFaceDir bool
19323                         LegacyMounted bool
19324
19325                         DigPredict string
19326
19327                         MaxLvl uint8
19328
19329                         AlphaUse
19330
19331                         MoveResistance uint8
19332
19333                         LiquidMovePhysics bool
19334                 }))(obj)).Name) = string(local248)
19335                 var local250 uint16
19336                 {
19337                         p := &local250
19338                         *p = read16(r)
19339                 }
19340                 ((*(*(struct {
19341                         Param0 Content
19342
19343                         Name   string
19344                         Groups []Group
19345
19346                         P1Type   Param1Type
19347                         P2Type   Param2Type
19348                         DrawType DrawType
19349
19350                         Mesh  string
19351                         Scale float32
19352                         //mt:const uint8(6)
19353                         Tiles        [6]TileDef
19354                         OverlayTiles [6]TileDef
19355                         //mt:const uint8(6)
19356                         SpecialTiles [6]TileDef
19357
19358                         Color   color.NRGBA
19359                         Palette Texture
19360
19361                         Waving       WaveType
19362                         ConnectSides uint8
19363                         ConnectTo    []Content
19364                         InsideTint   color.NRGBA
19365                         Level        uint8 // Must be < 128.
19366
19367                         Translucent bool // Sunlight is scattered and becomes normal light.
19368                         Transparent bool // Sunlight isn't scattered.
19369                         LightSrc    uint8
19370
19371                         GndContent   bool
19372                         Collides     bool
19373                         Pointable    bool
19374                         Diggable     bool
19375                         Climbable    bool
19376                         Replaceable  bool
19377                         OnRightClick bool
19378
19379                         DmgPerSec int32
19380
19381                         LiquidType   LiquidType
19382                         FlowingAlt   string
19383                         SrcAlt       string
19384                         Viscosity    uint8 // 0-7
19385                         LiqRenewable bool
19386                         FlowRange    uint8
19387                         DrownDmg     uint8
19388                         Floodable    bool
19389
19390                         DrawBox, ColBox, SelBox NodeBox
19391
19392                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19393
19394                         LegacyFaceDir bool
19395                         LegacyMounted bool
19396
19397                         DigPredict string
19398
19399                         MaxLvl uint8
19400
19401                         AlphaUse
19402
19403                         MoveResistance uint8
19404
19405                         LiquidMovePhysics bool
19406                 }))(obj)).Groups) = make([]Group, local250)
19407                 for local251 := range (*(*(struct {
19408                         Param0 Content
19409
19410                         Name   string
19411                         Groups []Group
19412
19413                         P1Type   Param1Type
19414                         P2Type   Param2Type
19415                         DrawType DrawType
19416
19417                         Mesh  string
19418                         Scale float32
19419                         //mt:const uint8(6)
19420                         Tiles        [6]TileDef
19421                         OverlayTiles [6]TileDef
19422                         //mt:const uint8(6)
19423                         SpecialTiles [6]TileDef
19424
19425                         Color   color.NRGBA
19426                         Palette Texture
19427
19428                         Waving       WaveType
19429                         ConnectSides uint8
19430                         ConnectTo    []Content
19431                         InsideTint   color.NRGBA
19432                         Level        uint8 // Must be < 128.
19433
19434                         Translucent bool // Sunlight is scattered and becomes normal light.
19435                         Transparent bool // Sunlight isn't scattered.
19436                         LightSrc    uint8
19437
19438                         GndContent   bool
19439                         Collides     bool
19440                         Pointable    bool
19441                         Diggable     bool
19442                         Climbable    bool
19443                         Replaceable  bool
19444                         OnRightClick bool
19445
19446                         DmgPerSec int32
19447
19448                         LiquidType   LiquidType
19449                         FlowingAlt   string
19450                         SrcAlt       string
19451                         Viscosity    uint8 // 0-7
19452                         LiqRenewable bool
19453                         FlowRange    uint8
19454                         DrownDmg     uint8
19455                         Floodable    bool
19456
19457                         DrawBox, ColBox, SelBox NodeBox
19458
19459                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19460
19461                         LegacyFaceDir bool
19462                         LegacyMounted bool
19463
19464                         DigPredict string
19465
19466                         MaxLvl uint8
19467
19468                         AlphaUse
19469
19470                         MoveResistance uint8
19471
19472                         LiquidMovePhysics bool
19473                 }))(obj)).Groups {
19474                         if err := pcall(func() {
19475                                 (((*(*(struct {
19476                                         Param0 Content
19477
19478                                         Name   string
19479                                         Groups []Group
19480
19481                                         P1Type   Param1Type
19482                                         P2Type   Param2Type
19483                                         DrawType DrawType
19484
19485                                         Mesh  string
19486                                         Scale float32
19487                                         //mt:const uint8(6)
19488                                         Tiles        [6]TileDef
19489                                         OverlayTiles [6]TileDef
19490                                         //mt:const uint8(6)
19491                                         SpecialTiles [6]TileDef
19492
19493                                         Color   color.NRGBA
19494                                         Palette Texture
19495
19496                                         Waving       WaveType
19497                                         ConnectSides uint8
19498                                         ConnectTo    []Content
19499                                         InsideTint   color.NRGBA
19500                                         Level        uint8 // Must be < 128.
19501
19502                                         Translucent bool // Sunlight is scattered and becomes normal light.
19503                                         Transparent bool // Sunlight isn't scattered.
19504                                         LightSrc    uint8
19505
19506                                         GndContent   bool
19507                                         Collides     bool
19508                                         Pointable    bool
19509                                         Diggable     bool
19510                                         Climbable    bool
19511                                         Replaceable  bool
19512                                         OnRightClick bool
19513
19514                                         DmgPerSec int32
19515
19516                                         LiquidType   LiquidType
19517                                         FlowingAlt   string
19518                                         SrcAlt       string
19519                                         Viscosity    uint8 // 0-7
19520                                         LiqRenewable bool
19521                                         FlowRange    uint8
19522                                         DrownDmg     uint8
19523                                         Floodable    bool
19524
19525                                         DrawBox, ColBox, SelBox NodeBox
19526
19527                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19528
19529                                         LegacyFaceDir bool
19530                                         LegacyMounted bool
19531
19532                                         DigPredict string
19533
19534                                         MaxLvl uint8
19535
19536                                         AlphaUse
19537
19538                                         MoveResistance uint8
19539
19540                                         LiquidMovePhysics bool
19541                                 }))(obj)).Groups)[local251]).deserialize(r)
19542                         }); err != nil {
19543                                 if err == io.EOF {
19544                                         chk(io.EOF)
19545                                 }
19546                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
19547                         }
19548                 }
19549                 if err := pcall(func() {
19550                         ((*(*(struct {
19551                                 Param0 Content
19552
19553                                 Name   string
19554                                 Groups []Group
19555
19556                                 P1Type   Param1Type
19557                                 P2Type   Param2Type
19558                                 DrawType DrawType
19559
19560                                 Mesh  string
19561                                 Scale float32
19562                                 //mt:const uint8(6)
19563                                 Tiles        [6]TileDef
19564                                 OverlayTiles [6]TileDef
19565                                 //mt:const uint8(6)
19566                                 SpecialTiles [6]TileDef
19567
19568                                 Color   color.NRGBA
19569                                 Palette Texture
19570
19571                                 Waving       WaveType
19572                                 ConnectSides uint8
19573                                 ConnectTo    []Content
19574                                 InsideTint   color.NRGBA
19575                                 Level        uint8 // Must be < 128.
19576
19577                                 Translucent bool // Sunlight is scattered and becomes normal light.
19578                                 Transparent bool // Sunlight isn't scattered.
19579                                 LightSrc    uint8
19580
19581                                 GndContent   bool
19582                                 Collides     bool
19583                                 Pointable    bool
19584                                 Diggable     bool
19585                                 Climbable    bool
19586                                 Replaceable  bool
19587                                 OnRightClick bool
19588
19589                                 DmgPerSec int32
19590
19591                                 LiquidType   LiquidType
19592                                 FlowingAlt   string
19593                                 SrcAlt       string
19594                                 Viscosity    uint8 // 0-7
19595                                 LiqRenewable bool
19596                                 FlowRange    uint8
19597                                 DrownDmg     uint8
19598                                 Floodable    bool
19599
19600                                 DrawBox, ColBox, SelBox NodeBox
19601
19602                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19603
19604                                 LegacyFaceDir bool
19605                                 LegacyMounted bool
19606
19607                                 DigPredict string
19608
19609                                 MaxLvl uint8
19610
19611                                 AlphaUse
19612
19613                                 MoveResistance uint8
19614
19615                                 LiquidMovePhysics bool
19616                         }))(obj)).P1Type).deserialize(r)
19617                 }); err != nil {
19618                         if err == io.EOF {
19619                                 chk(io.EOF)
19620                         }
19621                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param1Type", err))
19622                 }
19623                 if err := pcall(func() {
19624                         ((*(*(struct {
19625                                 Param0 Content
19626
19627                                 Name   string
19628                                 Groups []Group
19629
19630                                 P1Type   Param1Type
19631                                 P2Type   Param2Type
19632                                 DrawType DrawType
19633
19634                                 Mesh  string
19635                                 Scale float32
19636                                 //mt:const uint8(6)
19637                                 Tiles        [6]TileDef
19638                                 OverlayTiles [6]TileDef
19639                                 //mt:const uint8(6)
19640                                 SpecialTiles [6]TileDef
19641
19642                                 Color   color.NRGBA
19643                                 Palette Texture
19644
19645                                 Waving       WaveType
19646                                 ConnectSides uint8
19647                                 ConnectTo    []Content
19648                                 InsideTint   color.NRGBA
19649                                 Level        uint8 // Must be < 128.
19650
19651                                 Translucent bool // Sunlight is scattered and becomes normal light.
19652                                 Transparent bool // Sunlight isn't scattered.
19653                                 LightSrc    uint8
19654
19655                                 GndContent   bool
19656                                 Collides     bool
19657                                 Pointable    bool
19658                                 Diggable     bool
19659                                 Climbable    bool
19660                                 Replaceable  bool
19661                                 OnRightClick bool
19662
19663                                 DmgPerSec int32
19664
19665                                 LiquidType   LiquidType
19666                                 FlowingAlt   string
19667                                 SrcAlt       string
19668                                 Viscosity    uint8 // 0-7
19669                                 LiqRenewable bool
19670                                 FlowRange    uint8
19671                                 DrownDmg     uint8
19672                                 Floodable    bool
19673
19674                                 DrawBox, ColBox, SelBox NodeBox
19675
19676                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19677
19678                                 LegacyFaceDir bool
19679                                 LegacyMounted bool
19680
19681                                 DigPredict string
19682
19683                                 MaxLvl uint8
19684
19685                                 AlphaUse
19686
19687                                 MoveResistance uint8
19688
19689                                 LiquidMovePhysics bool
19690                         }))(obj)).P2Type).deserialize(r)
19691                 }); err != nil {
19692                         if err == io.EOF {
19693                                 chk(io.EOF)
19694                         }
19695                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Param2Type", err))
19696                 }
19697                 if err := pcall(func() {
19698                         ((*(*(struct {
19699                                 Param0 Content
19700
19701                                 Name   string
19702                                 Groups []Group
19703
19704                                 P1Type   Param1Type
19705                                 P2Type   Param2Type
19706                                 DrawType DrawType
19707
19708                                 Mesh  string
19709                                 Scale float32
19710                                 //mt:const uint8(6)
19711                                 Tiles        [6]TileDef
19712                                 OverlayTiles [6]TileDef
19713                                 //mt:const uint8(6)
19714                                 SpecialTiles [6]TileDef
19715
19716                                 Color   color.NRGBA
19717                                 Palette Texture
19718
19719                                 Waving       WaveType
19720                                 ConnectSides uint8
19721                                 ConnectTo    []Content
19722                                 InsideTint   color.NRGBA
19723                                 Level        uint8 // Must be < 128.
19724
19725                                 Translucent bool // Sunlight is scattered and becomes normal light.
19726                                 Transparent bool // Sunlight isn't scattered.
19727                                 LightSrc    uint8
19728
19729                                 GndContent   bool
19730                                 Collides     bool
19731                                 Pointable    bool
19732                                 Diggable     bool
19733                                 Climbable    bool
19734                                 Replaceable  bool
19735                                 OnRightClick bool
19736
19737                                 DmgPerSec int32
19738
19739                                 LiquidType   LiquidType
19740                                 FlowingAlt   string
19741                                 SrcAlt       string
19742                                 Viscosity    uint8 // 0-7
19743                                 LiqRenewable bool
19744                                 FlowRange    uint8
19745                                 DrownDmg     uint8
19746                                 Floodable    bool
19747
19748                                 DrawBox, ColBox, SelBox NodeBox
19749
19750                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19751
19752                                 LegacyFaceDir bool
19753                                 LegacyMounted bool
19754
19755                                 DigPredict string
19756
19757                                 MaxLvl uint8
19758
19759                                 AlphaUse
19760
19761                                 MoveResistance uint8
19762
19763                                 LiquidMovePhysics bool
19764                         }))(obj)).DrawType).deserialize(r)
19765                 }); err != nil {
19766                         if err == io.EOF {
19767                                 chk(io.EOF)
19768                         }
19769                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DrawType", err))
19770                 }
19771                 var local252 []uint8
19772                 var local253 uint16
19773                 {
19774                         p := &local253
19775                         *p = read16(r)
19776                 }
19777                 (local252) = make([]uint8, local253)
19778                 {
19779                         _, err := io.ReadFull(r, (local252)[:])
19780                         chk(err)
19781                 }
19782                 ((*(*(struct {
19783                         Param0 Content
19784
19785                         Name   string
19786                         Groups []Group
19787
19788                         P1Type   Param1Type
19789                         P2Type   Param2Type
19790                         DrawType DrawType
19791
19792                         Mesh  string
19793                         Scale float32
19794                         //mt:const uint8(6)
19795                         Tiles        [6]TileDef
19796                         OverlayTiles [6]TileDef
19797                         //mt:const uint8(6)
19798                         SpecialTiles [6]TileDef
19799
19800                         Color   color.NRGBA
19801                         Palette Texture
19802
19803                         Waving       WaveType
19804                         ConnectSides uint8
19805                         ConnectTo    []Content
19806                         InsideTint   color.NRGBA
19807                         Level        uint8 // Must be < 128.
19808
19809                         Translucent bool // Sunlight is scattered and becomes normal light.
19810                         Transparent bool // Sunlight isn't scattered.
19811                         LightSrc    uint8
19812
19813                         GndContent   bool
19814                         Collides     bool
19815                         Pointable    bool
19816                         Diggable     bool
19817                         Climbable    bool
19818                         Replaceable  bool
19819                         OnRightClick bool
19820
19821                         DmgPerSec int32
19822
19823                         LiquidType   LiquidType
19824                         FlowingAlt   string
19825                         SrcAlt       string
19826                         Viscosity    uint8 // 0-7
19827                         LiqRenewable bool
19828                         FlowRange    uint8
19829                         DrownDmg     uint8
19830                         Floodable    bool
19831
19832                         DrawBox, ColBox, SelBox NodeBox
19833
19834                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19835
19836                         LegacyFaceDir bool
19837                         LegacyMounted bool
19838
19839                         DigPredict string
19840
19841                         MaxLvl uint8
19842
19843                         AlphaUse
19844
19845                         MoveResistance uint8
19846
19847                         LiquidMovePhysics bool
19848                 }))(obj)).Mesh) = string(local252)
19849                 {
19850                         p := &(*(*(struct {
19851                                 Param0 Content
19852
19853                                 Name   string
19854                                 Groups []Group
19855
19856                                 P1Type   Param1Type
19857                                 P2Type   Param2Type
19858                                 DrawType DrawType
19859
19860                                 Mesh  string
19861                                 Scale float32
19862                                 //mt:const uint8(6)
19863                                 Tiles        [6]TileDef
19864                                 OverlayTiles [6]TileDef
19865                                 //mt:const uint8(6)
19866                                 SpecialTiles [6]TileDef
19867
19868                                 Color   color.NRGBA
19869                                 Palette Texture
19870
19871                                 Waving       WaveType
19872                                 ConnectSides uint8
19873                                 ConnectTo    []Content
19874                                 InsideTint   color.NRGBA
19875                                 Level        uint8 // Must be < 128.
19876
19877                                 Translucent bool // Sunlight is scattered and becomes normal light.
19878                                 Transparent bool // Sunlight isn't scattered.
19879                                 LightSrc    uint8
19880
19881                                 GndContent   bool
19882                                 Collides     bool
19883                                 Pointable    bool
19884                                 Diggable     bool
19885                                 Climbable    bool
19886                                 Replaceable  bool
19887                                 OnRightClick bool
19888
19889                                 DmgPerSec int32
19890
19891                                 LiquidType   LiquidType
19892                                 FlowingAlt   string
19893                                 SrcAlt       string
19894                                 Viscosity    uint8 // 0-7
19895                                 LiqRenewable bool
19896                                 FlowRange    uint8
19897                                 DrownDmg     uint8
19898                                 Floodable    bool
19899
19900                                 DrawBox, ColBox, SelBox NodeBox
19901
19902                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
19903
19904                                 LegacyFaceDir bool
19905                                 LegacyMounted bool
19906
19907                                 DigPredict string
19908
19909                                 MaxLvl uint8
19910
19911                                 AlphaUse
19912
19913                                 MoveResistance uint8
19914
19915                                 LiquidMovePhysics bool
19916                         }))(obj)).Scale
19917                         *p = math.Float32frombits(read32(r))
19918                 }
19919                 {
19920                         var local254 uint8
19921                         local255 := uint8(6)
19922                         {
19923                                 p := &local254
19924                                 *p = read8(r)
19925                         }
19926                         if local254 != local255 {
19927                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local254))
19928                         }
19929                 }
19930                 for local256 := range (*(*(struct {
19931                         Param0 Content
19932
19933                         Name   string
19934                         Groups []Group
19935
19936                         P1Type   Param1Type
19937                         P2Type   Param2Type
19938                         DrawType DrawType
19939
19940                         Mesh  string
19941                         Scale float32
19942                         //mt:const uint8(6)
19943                         Tiles        [6]TileDef
19944                         OverlayTiles [6]TileDef
19945                         //mt:const uint8(6)
19946                         SpecialTiles [6]TileDef
19947
19948                         Color   color.NRGBA
19949                         Palette Texture
19950
19951                         Waving       WaveType
19952                         ConnectSides uint8
19953                         ConnectTo    []Content
19954                         InsideTint   color.NRGBA
19955                         Level        uint8 // Must be < 128.
19956
19957                         Translucent bool // Sunlight is scattered and becomes normal light.
19958                         Transparent bool // Sunlight isn't scattered.
19959                         LightSrc    uint8
19960
19961                         GndContent   bool
19962                         Collides     bool
19963                         Pointable    bool
19964                         Diggable     bool
19965                         Climbable    bool
19966                         Replaceable  bool
19967                         OnRightClick bool
19968
19969                         DmgPerSec int32
19970
19971                         LiquidType   LiquidType
19972                         FlowingAlt   string
19973                         SrcAlt       string
19974                         Viscosity    uint8 // 0-7
19975                         LiqRenewable bool
19976                         FlowRange    uint8
19977                         DrownDmg     uint8
19978                         Floodable    bool
19979
19980                         DrawBox, ColBox, SelBox NodeBox
19981
19982                         FootstepSnd, DiggingSnd, DugSnd SoundDef
19983
19984                         LegacyFaceDir bool
19985                         LegacyMounted bool
19986
19987                         DigPredict string
19988
19989                         MaxLvl uint8
19990
19991                         AlphaUse
19992
19993                         MoveResistance uint8
19994
19995                         LiquidMovePhysics bool
19996                 }))(obj)).Tiles {
19997                         if err := pcall(func() {
19998                                 (((*(*(struct {
19999                                         Param0 Content
20000
20001                                         Name   string
20002                                         Groups []Group
20003
20004                                         P1Type   Param1Type
20005                                         P2Type   Param2Type
20006                                         DrawType DrawType
20007
20008                                         Mesh  string
20009                                         Scale float32
20010                                         //mt:const uint8(6)
20011                                         Tiles        [6]TileDef
20012                                         OverlayTiles [6]TileDef
20013                                         //mt:const uint8(6)
20014                                         SpecialTiles [6]TileDef
20015
20016                                         Color   color.NRGBA
20017                                         Palette Texture
20018
20019                                         Waving       WaveType
20020                                         ConnectSides uint8
20021                                         ConnectTo    []Content
20022                                         InsideTint   color.NRGBA
20023                                         Level        uint8 // Must be < 128.
20024
20025                                         Translucent bool // Sunlight is scattered and becomes normal light.
20026                                         Transparent bool // Sunlight isn't scattered.
20027                                         LightSrc    uint8
20028
20029                                         GndContent   bool
20030                                         Collides     bool
20031                                         Pointable    bool
20032                                         Diggable     bool
20033                                         Climbable    bool
20034                                         Replaceable  bool
20035                                         OnRightClick bool
20036
20037                                         DmgPerSec int32
20038
20039                                         LiquidType   LiquidType
20040                                         FlowingAlt   string
20041                                         SrcAlt       string
20042                                         Viscosity    uint8 // 0-7
20043                                         LiqRenewable bool
20044                                         FlowRange    uint8
20045                                         DrownDmg     uint8
20046                                         Floodable    bool
20047
20048                                         DrawBox, ColBox, SelBox NodeBox
20049
20050                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20051
20052                                         LegacyFaceDir bool
20053                                         LegacyMounted bool
20054
20055                                         DigPredict string
20056
20057                                         MaxLvl uint8
20058
20059                                         AlphaUse
20060
20061                                         MoveResistance uint8
20062
20063                                         LiquidMovePhysics bool
20064                                 }))(obj)).Tiles)[local256]).deserialize(r)
20065                         }); err != nil {
20066                                 if err == io.EOF {
20067                                         chk(io.EOF)
20068                                 }
20069                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20070                         }
20071                 }
20072                 for local257 := range (*(*(struct {
20073                         Param0 Content
20074
20075                         Name   string
20076                         Groups []Group
20077
20078                         P1Type   Param1Type
20079                         P2Type   Param2Type
20080                         DrawType DrawType
20081
20082                         Mesh  string
20083                         Scale float32
20084                         //mt:const uint8(6)
20085                         Tiles        [6]TileDef
20086                         OverlayTiles [6]TileDef
20087                         //mt:const uint8(6)
20088                         SpecialTiles [6]TileDef
20089
20090                         Color   color.NRGBA
20091                         Palette Texture
20092
20093                         Waving       WaveType
20094                         ConnectSides uint8
20095                         ConnectTo    []Content
20096                         InsideTint   color.NRGBA
20097                         Level        uint8 // Must be < 128.
20098
20099                         Translucent bool // Sunlight is scattered and becomes normal light.
20100                         Transparent bool // Sunlight isn't scattered.
20101                         LightSrc    uint8
20102
20103                         GndContent   bool
20104                         Collides     bool
20105                         Pointable    bool
20106                         Diggable     bool
20107                         Climbable    bool
20108                         Replaceable  bool
20109                         OnRightClick bool
20110
20111                         DmgPerSec int32
20112
20113                         LiquidType   LiquidType
20114                         FlowingAlt   string
20115                         SrcAlt       string
20116                         Viscosity    uint8 // 0-7
20117                         LiqRenewable bool
20118                         FlowRange    uint8
20119                         DrownDmg     uint8
20120                         Floodable    bool
20121
20122                         DrawBox, ColBox, SelBox NodeBox
20123
20124                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20125
20126                         LegacyFaceDir bool
20127                         LegacyMounted bool
20128
20129                         DigPredict string
20130
20131                         MaxLvl uint8
20132
20133                         AlphaUse
20134
20135                         MoveResistance uint8
20136
20137                         LiquidMovePhysics bool
20138                 }))(obj)).OverlayTiles {
20139                         if err := pcall(func() {
20140                                 (((*(*(struct {
20141                                         Param0 Content
20142
20143                                         Name   string
20144                                         Groups []Group
20145
20146                                         P1Type   Param1Type
20147                                         P2Type   Param2Type
20148                                         DrawType DrawType
20149
20150                                         Mesh  string
20151                                         Scale float32
20152                                         //mt:const uint8(6)
20153                                         Tiles        [6]TileDef
20154                                         OverlayTiles [6]TileDef
20155                                         //mt:const uint8(6)
20156                                         SpecialTiles [6]TileDef
20157
20158                                         Color   color.NRGBA
20159                                         Palette Texture
20160
20161                                         Waving       WaveType
20162                                         ConnectSides uint8
20163                                         ConnectTo    []Content
20164                                         InsideTint   color.NRGBA
20165                                         Level        uint8 // Must be < 128.
20166
20167                                         Translucent bool // Sunlight is scattered and becomes normal light.
20168                                         Transparent bool // Sunlight isn't scattered.
20169                                         LightSrc    uint8
20170
20171                                         GndContent   bool
20172                                         Collides     bool
20173                                         Pointable    bool
20174                                         Diggable     bool
20175                                         Climbable    bool
20176                                         Replaceable  bool
20177                                         OnRightClick bool
20178
20179                                         DmgPerSec int32
20180
20181                                         LiquidType   LiquidType
20182                                         FlowingAlt   string
20183                                         SrcAlt       string
20184                                         Viscosity    uint8 // 0-7
20185                                         LiqRenewable bool
20186                                         FlowRange    uint8
20187                                         DrownDmg     uint8
20188                                         Floodable    bool
20189
20190                                         DrawBox, ColBox, SelBox NodeBox
20191
20192                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20193
20194                                         LegacyFaceDir bool
20195                                         LegacyMounted bool
20196
20197                                         DigPredict string
20198
20199                                         MaxLvl uint8
20200
20201                                         AlphaUse
20202
20203                                         MoveResistance uint8
20204
20205                                         LiquidMovePhysics bool
20206                                 }))(obj)).OverlayTiles)[local257]).deserialize(r)
20207                         }); err != nil {
20208                                 if err == io.EOF {
20209                                         chk(io.EOF)
20210                                 }
20211                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20212                         }
20213                 }
20214                 {
20215                         var local258 uint8
20216                         local259 := uint8(6)
20217                         {
20218                                 p := &local258
20219                                 *p = read8(r)
20220                         }
20221                         if local258 != local259 {
20222                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local258))
20223                         }
20224                 }
20225                 for local260 := range (*(*(struct {
20226                         Param0 Content
20227
20228                         Name   string
20229                         Groups []Group
20230
20231                         P1Type   Param1Type
20232                         P2Type   Param2Type
20233                         DrawType DrawType
20234
20235                         Mesh  string
20236                         Scale float32
20237                         //mt:const uint8(6)
20238                         Tiles        [6]TileDef
20239                         OverlayTiles [6]TileDef
20240                         //mt:const uint8(6)
20241                         SpecialTiles [6]TileDef
20242
20243                         Color   color.NRGBA
20244                         Palette Texture
20245
20246                         Waving       WaveType
20247                         ConnectSides uint8
20248                         ConnectTo    []Content
20249                         InsideTint   color.NRGBA
20250                         Level        uint8 // Must be < 128.
20251
20252                         Translucent bool // Sunlight is scattered and becomes normal light.
20253                         Transparent bool // Sunlight isn't scattered.
20254                         LightSrc    uint8
20255
20256                         GndContent   bool
20257                         Collides     bool
20258                         Pointable    bool
20259                         Diggable     bool
20260                         Climbable    bool
20261                         Replaceable  bool
20262                         OnRightClick bool
20263
20264                         DmgPerSec int32
20265
20266                         LiquidType   LiquidType
20267                         FlowingAlt   string
20268                         SrcAlt       string
20269                         Viscosity    uint8 // 0-7
20270                         LiqRenewable bool
20271                         FlowRange    uint8
20272                         DrownDmg     uint8
20273                         Floodable    bool
20274
20275                         DrawBox, ColBox, SelBox NodeBox
20276
20277                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20278
20279                         LegacyFaceDir bool
20280                         LegacyMounted bool
20281
20282                         DigPredict string
20283
20284                         MaxLvl uint8
20285
20286                         AlphaUse
20287
20288                         MoveResistance uint8
20289
20290                         LiquidMovePhysics bool
20291                 }))(obj)).SpecialTiles {
20292                         if err := pcall(func() {
20293                                 (((*(*(struct {
20294                                         Param0 Content
20295
20296                                         Name   string
20297                                         Groups []Group
20298
20299                                         P1Type   Param1Type
20300                                         P2Type   Param2Type
20301                                         DrawType DrawType
20302
20303                                         Mesh  string
20304                                         Scale float32
20305                                         //mt:const uint8(6)
20306                                         Tiles        [6]TileDef
20307                                         OverlayTiles [6]TileDef
20308                                         //mt:const uint8(6)
20309                                         SpecialTiles [6]TileDef
20310
20311                                         Color   color.NRGBA
20312                                         Palette Texture
20313
20314                                         Waving       WaveType
20315                                         ConnectSides uint8
20316                                         ConnectTo    []Content
20317                                         InsideTint   color.NRGBA
20318                                         Level        uint8 // Must be < 128.
20319
20320                                         Translucent bool // Sunlight is scattered and becomes normal light.
20321                                         Transparent bool // Sunlight isn't scattered.
20322                                         LightSrc    uint8
20323
20324                                         GndContent   bool
20325                                         Collides     bool
20326                                         Pointable    bool
20327                                         Diggable     bool
20328                                         Climbable    bool
20329                                         Replaceable  bool
20330                                         OnRightClick bool
20331
20332                                         DmgPerSec int32
20333
20334                                         LiquidType   LiquidType
20335                                         FlowingAlt   string
20336                                         SrcAlt       string
20337                                         Viscosity    uint8 // 0-7
20338                                         LiqRenewable bool
20339                                         FlowRange    uint8
20340                                         DrownDmg     uint8
20341                                         Floodable    bool
20342
20343                                         DrawBox, ColBox, SelBox NodeBox
20344
20345                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20346
20347                                         LegacyFaceDir bool
20348                                         LegacyMounted bool
20349
20350                                         DigPredict string
20351
20352                                         MaxLvl uint8
20353
20354                                         AlphaUse
20355
20356                                         MoveResistance uint8
20357
20358                                         LiquidMovePhysics bool
20359                                 }))(obj)).SpecialTiles)[local260]).deserialize(r)
20360                         }); err != nil {
20361                                 if err == io.EOF {
20362                                         chk(io.EOF)
20363                                 }
20364                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileDef", err))
20365                         }
20366                 }
20367                 {
20368                         p := &(*(*(struct {
20369                                 Param0 Content
20370
20371                                 Name   string
20372                                 Groups []Group
20373
20374                                 P1Type   Param1Type
20375                                 P2Type   Param2Type
20376                                 DrawType DrawType
20377
20378                                 Mesh  string
20379                                 Scale float32
20380                                 //mt:const uint8(6)
20381                                 Tiles        [6]TileDef
20382                                 OverlayTiles [6]TileDef
20383                                 //mt:const uint8(6)
20384                                 SpecialTiles [6]TileDef
20385
20386                                 Color   color.NRGBA
20387                                 Palette Texture
20388
20389                                 Waving       WaveType
20390                                 ConnectSides uint8
20391                                 ConnectTo    []Content
20392                                 InsideTint   color.NRGBA
20393                                 Level        uint8 // Must be < 128.
20394
20395                                 Translucent bool // Sunlight is scattered and becomes normal light.
20396                                 Transparent bool // Sunlight isn't scattered.
20397                                 LightSrc    uint8
20398
20399                                 GndContent   bool
20400                                 Collides     bool
20401                                 Pointable    bool
20402                                 Diggable     bool
20403                                 Climbable    bool
20404                                 Replaceable  bool
20405                                 OnRightClick bool
20406
20407                                 DmgPerSec int32
20408
20409                                 LiquidType   LiquidType
20410                                 FlowingAlt   string
20411                                 SrcAlt       string
20412                                 Viscosity    uint8 // 0-7
20413                                 LiqRenewable bool
20414                                 FlowRange    uint8
20415                                 DrownDmg     uint8
20416                                 Floodable    bool
20417
20418                                 DrawBox, ColBox, SelBox NodeBox
20419
20420                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20421
20422                                 LegacyFaceDir bool
20423                                 LegacyMounted bool
20424
20425                                 DigPredict string
20426
20427                                 MaxLvl uint8
20428
20429                                 AlphaUse
20430
20431                                 MoveResistance uint8
20432
20433                                 LiquidMovePhysics bool
20434                         }))(obj)).Color
20435                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20436                 }
20437                 if err := pcall(func() {
20438                         ((*(*(struct {
20439                                 Param0 Content
20440
20441                                 Name   string
20442                                 Groups []Group
20443
20444                                 P1Type   Param1Type
20445                                 P2Type   Param2Type
20446                                 DrawType DrawType
20447
20448                                 Mesh  string
20449                                 Scale float32
20450                                 //mt:const uint8(6)
20451                                 Tiles        [6]TileDef
20452                                 OverlayTiles [6]TileDef
20453                                 //mt:const uint8(6)
20454                                 SpecialTiles [6]TileDef
20455
20456                                 Color   color.NRGBA
20457                                 Palette Texture
20458
20459                                 Waving       WaveType
20460                                 ConnectSides uint8
20461                                 ConnectTo    []Content
20462                                 InsideTint   color.NRGBA
20463                                 Level        uint8 // Must be < 128.
20464
20465                                 Translucent bool // Sunlight is scattered and becomes normal light.
20466                                 Transparent bool // Sunlight isn't scattered.
20467                                 LightSrc    uint8
20468
20469                                 GndContent   bool
20470                                 Collides     bool
20471                                 Pointable    bool
20472                                 Diggable     bool
20473                                 Climbable    bool
20474                                 Replaceable  bool
20475                                 OnRightClick bool
20476
20477                                 DmgPerSec int32
20478
20479                                 LiquidType   LiquidType
20480                                 FlowingAlt   string
20481                                 SrcAlt       string
20482                                 Viscosity    uint8 // 0-7
20483                                 LiqRenewable bool
20484                                 FlowRange    uint8
20485                                 DrownDmg     uint8
20486                                 Floodable    bool
20487
20488                                 DrawBox, ColBox, SelBox NodeBox
20489
20490                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20491
20492                                 LegacyFaceDir bool
20493                                 LegacyMounted bool
20494
20495                                 DigPredict string
20496
20497                                 MaxLvl uint8
20498
20499                                 AlphaUse
20500
20501                                 MoveResistance uint8
20502
20503                                 LiquidMovePhysics bool
20504                         }))(obj)).Palette).deserialize(r)
20505                 }); err != nil {
20506                         if err == io.EOF {
20507                                 chk(io.EOF)
20508                         }
20509                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
20510                 }
20511                 if err := pcall(func() {
20512                         ((*(*(struct {
20513                                 Param0 Content
20514
20515                                 Name   string
20516                                 Groups []Group
20517
20518                                 P1Type   Param1Type
20519                                 P2Type   Param2Type
20520                                 DrawType DrawType
20521
20522                                 Mesh  string
20523                                 Scale float32
20524                                 //mt:const uint8(6)
20525                                 Tiles        [6]TileDef
20526                                 OverlayTiles [6]TileDef
20527                                 //mt:const uint8(6)
20528                                 SpecialTiles [6]TileDef
20529
20530                                 Color   color.NRGBA
20531                                 Palette Texture
20532
20533                                 Waving       WaveType
20534                                 ConnectSides uint8
20535                                 ConnectTo    []Content
20536                                 InsideTint   color.NRGBA
20537                                 Level        uint8 // Must be < 128.
20538
20539                                 Translucent bool // Sunlight is scattered and becomes normal light.
20540                                 Transparent bool // Sunlight isn't scattered.
20541                                 LightSrc    uint8
20542
20543                                 GndContent   bool
20544                                 Collides     bool
20545                                 Pointable    bool
20546                                 Diggable     bool
20547                                 Climbable    bool
20548                                 Replaceable  bool
20549                                 OnRightClick bool
20550
20551                                 DmgPerSec int32
20552
20553                                 LiquidType   LiquidType
20554                                 FlowingAlt   string
20555                                 SrcAlt       string
20556                                 Viscosity    uint8 // 0-7
20557                                 LiqRenewable bool
20558                                 FlowRange    uint8
20559                                 DrownDmg     uint8
20560                                 Floodable    bool
20561
20562                                 DrawBox, ColBox, SelBox NodeBox
20563
20564                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20565
20566                                 LegacyFaceDir bool
20567                                 LegacyMounted bool
20568
20569                                 DigPredict string
20570
20571                                 MaxLvl uint8
20572
20573                                 AlphaUse
20574
20575                                 MoveResistance uint8
20576
20577                                 LiquidMovePhysics bool
20578                         }))(obj)).Waving).deserialize(r)
20579                 }); err != nil {
20580                         if err == io.EOF {
20581                                 chk(io.EOF)
20582                         }
20583                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.WaveType", err))
20584                 }
20585                 {
20586                         p := &(*(*(struct {
20587                                 Param0 Content
20588
20589                                 Name   string
20590                                 Groups []Group
20591
20592                                 P1Type   Param1Type
20593                                 P2Type   Param2Type
20594                                 DrawType DrawType
20595
20596                                 Mesh  string
20597                                 Scale float32
20598                                 //mt:const uint8(6)
20599                                 Tiles        [6]TileDef
20600                                 OverlayTiles [6]TileDef
20601                                 //mt:const uint8(6)
20602                                 SpecialTiles [6]TileDef
20603
20604                                 Color   color.NRGBA
20605                                 Palette Texture
20606
20607                                 Waving       WaveType
20608                                 ConnectSides uint8
20609                                 ConnectTo    []Content
20610                                 InsideTint   color.NRGBA
20611                                 Level        uint8 // Must be < 128.
20612
20613                                 Translucent bool // Sunlight is scattered and becomes normal light.
20614                                 Transparent bool // Sunlight isn't scattered.
20615                                 LightSrc    uint8
20616
20617                                 GndContent   bool
20618                                 Collides     bool
20619                                 Pointable    bool
20620                                 Diggable     bool
20621                                 Climbable    bool
20622                                 Replaceable  bool
20623                                 OnRightClick bool
20624
20625                                 DmgPerSec int32
20626
20627                                 LiquidType   LiquidType
20628                                 FlowingAlt   string
20629                                 SrcAlt       string
20630                                 Viscosity    uint8 // 0-7
20631                                 LiqRenewable bool
20632                                 FlowRange    uint8
20633                                 DrownDmg     uint8
20634                                 Floodable    bool
20635
20636                                 DrawBox, ColBox, SelBox NodeBox
20637
20638                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20639
20640                                 LegacyFaceDir bool
20641                                 LegacyMounted bool
20642
20643                                 DigPredict string
20644
20645                                 MaxLvl uint8
20646
20647                                 AlphaUse
20648
20649                                 MoveResistance uint8
20650
20651                                 LiquidMovePhysics bool
20652                         }))(obj)).ConnectSides
20653                         *p = read8(r)
20654                 }
20655                 var local261 uint16
20656                 {
20657                         p := &local261
20658                         *p = read16(r)
20659                 }
20660                 ((*(*(struct {
20661                         Param0 Content
20662
20663                         Name   string
20664                         Groups []Group
20665
20666                         P1Type   Param1Type
20667                         P2Type   Param2Type
20668                         DrawType DrawType
20669
20670                         Mesh  string
20671                         Scale float32
20672                         //mt:const uint8(6)
20673                         Tiles        [6]TileDef
20674                         OverlayTiles [6]TileDef
20675                         //mt:const uint8(6)
20676                         SpecialTiles [6]TileDef
20677
20678                         Color   color.NRGBA
20679                         Palette Texture
20680
20681                         Waving       WaveType
20682                         ConnectSides uint8
20683                         ConnectTo    []Content
20684                         InsideTint   color.NRGBA
20685                         Level        uint8 // Must be < 128.
20686
20687                         Translucent bool // Sunlight is scattered and becomes normal light.
20688                         Transparent bool // Sunlight isn't scattered.
20689                         LightSrc    uint8
20690
20691                         GndContent   bool
20692                         Collides     bool
20693                         Pointable    bool
20694                         Diggable     bool
20695                         Climbable    bool
20696                         Replaceable  bool
20697                         OnRightClick bool
20698
20699                         DmgPerSec int32
20700
20701                         LiquidType   LiquidType
20702                         FlowingAlt   string
20703                         SrcAlt       string
20704                         Viscosity    uint8 // 0-7
20705                         LiqRenewable bool
20706                         FlowRange    uint8
20707                         DrownDmg     uint8
20708                         Floodable    bool
20709
20710                         DrawBox, ColBox, SelBox NodeBox
20711
20712                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20713
20714                         LegacyFaceDir bool
20715                         LegacyMounted bool
20716
20717                         DigPredict string
20718
20719                         MaxLvl uint8
20720
20721                         AlphaUse
20722
20723                         MoveResistance uint8
20724
20725                         LiquidMovePhysics bool
20726                 }))(obj)).ConnectTo) = make([]Content, local261)
20727                 for local262 := range (*(*(struct {
20728                         Param0 Content
20729
20730                         Name   string
20731                         Groups []Group
20732
20733                         P1Type   Param1Type
20734                         P2Type   Param2Type
20735                         DrawType DrawType
20736
20737                         Mesh  string
20738                         Scale float32
20739                         //mt:const uint8(6)
20740                         Tiles        [6]TileDef
20741                         OverlayTiles [6]TileDef
20742                         //mt:const uint8(6)
20743                         SpecialTiles [6]TileDef
20744
20745                         Color   color.NRGBA
20746                         Palette Texture
20747
20748                         Waving       WaveType
20749                         ConnectSides uint8
20750                         ConnectTo    []Content
20751                         InsideTint   color.NRGBA
20752                         Level        uint8 // Must be < 128.
20753
20754                         Translucent bool // Sunlight is scattered and becomes normal light.
20755                         Transparent bool // Sunlight isn't scattered.
20756                         LightSrc    uint8
20757
20758                         GndContent   bool
20759                         Collides     bool
20760                         Pointable    bool
20761                         Diggable     bool
20762                         Climbable    bool
20763                         Replaceable  bool
20764                         OnRightClick bool
20765
20766                         DmgPerSec int32
20767
20768                         LiquidType   LiquidType
20769                         FlowingAlt   string
20770                         SrcAlt       string
20771                         Viscosity    uint8 // 0-7
20772                         LiqRenewable bool
20773                         FlowRange    uint8
20774                         DrownDmg     uint8
20775                         Floodable    bool
20776
20777                         DrawBox, ColBox, SelBox NodeBox
20778
20779                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20780
20781                         LegacyFaceDir bool
20782                         LegacyMounted bool
20783
20784                         DigPredict string
20785
20786                         MaxLvl uint8
20787
20788                         AlphaUse
20789
20790                         MoveResistance uint8
20791
20792                         LiquidMovePhysics bool
20793                 }))(obj)).ConnectTo {
20794                         if err := pcall(func() {
20795                                 (((*(*(struct {
20796                                         Param0 Content
20797
20798                                         Name   string
20799                                         Groups []Group
20800
20801                                         P1Type   Param1Type
20802                                         P2Type   Param2Type
20803                                         DrawType DrawType
20804
20805                                         Mesh  string
20806                                         Scale float32
20807                                         //mt:const uint8(6)
20808                                         Tiles        [6]TileDef
20809                                         OverlayTiles [6]TileDef
20810                                         //mt:const uint8(6)
20811                                         SpecialTiles [6]TileDef
20812
20813                                         Color   color.NRGBA
20814                                         Palette Texture
20815
20816                                         Waving       WaveType
20817                                         ConnectSides uint8
20818                                         ConnectTo    []Content
20819                                         InsideTint   color.NRGBA
20820                                         Level        uint8 // Must be < 128.
20821
20822                                         Translucent bool // Sunlight is scattered and becomes normal light.
20823                                         Transparent bool // Sunlight isn't scattered.
20824                                         LightSrc    uint8
20825
20826                                         GndContent   bool
20827                                         Collides     bool
20828                                         Pointable    bool
20829                                         Diggable     bool
20830                                         Climbable    bool
20831                                         Replaceable  bool
20832                                         OnRightClick bool
20833
20834                                         DmgPerSec int32
20835
20836                                         LiquidType   LiquidType
20837                                         FlowingAlt   string
20838                                         SrcAlt       string
20839                                         Viscosity    uint8 // 0-7
20840                                         LiqRenewable bool
20841                                         FlowRange    uint8
20842                                         DrownDmg     uint8
20843                                         Floodable    bool
20844
20845                                         DrawBox, ColBox, SelBox NodeBox
20846
20847                                         FootstepSnd, DiggingSnd, DugSnd SoundDef
20848
20849                                         LegacyFaceDir bool
20850                                         LegacyMounted bool
20851
20852                                         DigPredict string
20853
20854                                         MaxLvl uint8
20855
20856                                         AlphaUse
20857
20858                                         MoveResistance uint8
20859
20860                                         LiquidMovePhysics bool
20861                                 }))(obj)).ConnectTo)[local262]).deserialize(r)
20862                         }); err != nil {
20863                                 if err == io.EOF {
20864                                         chk(io.EOF)
20865                                 }
20866                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
20867                         }
20868                 }
20869                 {
20870                         p := &(*(*(struct {
20871                                 Param0 Content
20872
20873                                 Name   string
20874                                 Groups []Group
20875
20876                                 P1Type   Param1Type
20877                                 P2Type   Param2Type
20878                                 DrawType DrawType
20879
20880                                 Mesh  string
20881                                 Scale float32
20882                                 //mt:const uint8(6)
20883                                 Tiles        [6]TileDef
20884                                 OverlayTiles [6]TileDef
20885                                 //mt:const uint8(6)
20886                                 SpecialTiles [6]TileDef
20887
20888                                 Color   color.NRGBA
20889                                 Palette Texture
20890
20891                                 Waving       WaveType
20892                                 ConnectSides uint8
20893                                 ConnectTo    []Content
20894                                 InsideTint   color.NRGBA
20895                                 Level        uint8 // Must be < 128.
20896
20897                                 Translucent bool // Sunlight is scattered and becomes normal light.
20898                                 Transparent bool // Sunlight isn't scattered.
20899                                 LightSrc    uint8
20900
20901                                 GndContent   bool
20902                                 Collides     bool
20903                                 Pointable    bool
20904                                 Diggable     bool
20905                                 Climbable    bool
20906                                 Replaceable  bool
20907                                 OnRightClick bool
20908
20909                                 DmgPerSec int32
20910
20911                                 LiquidType   LiquidType
20912                                 FlowingAlt   string
20913                                 SrcAlt       string
20914                                 Viscosity    uint8 // 0-7
20915                                 LiqRenewable bool
20916                                 FlowRange    uint8
20917                                 DrownDmg     uint8
20918                                 Floodable    bool
20919
20920                                 DrawBox, ColBox, SelBox NodeBox
20921
20922                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20923
20924                                 LegacyFaceDir bool
20925                                 LegacyMounted bool
20926
20927                                 DigPredict string
20928
20929                                 MaxLvl uint8
20930
20931                                 AlphaUse
20932
20933                                 MoveResistance uint8
20934
20935                                 LiquidMovePhysics bool
20936                         }))(obj)).InsideTint
20937                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
20938                 }
20939                 {
20940                         p := &(*(*(struct {
20941                                 Param0 Content
20942
20943                                 Name   string
20944                                 Groups []Group
20945
20946                                 P1Type   Param1Type
20947                                 P2Type   Param2Type
20948                                 DrawType DrawType
20949
20950                                 Mesh  string
20951                                 Scale float32
20952                                 //mt:const uint8(6)
20953                                 Tiles        [6]TileDef
20954                                 OverlayTiles [6]TileDef
20955                                 //mt:const uint8(6)
20956                                 SpecialTiles [6]TileDef
20957
20958                                 Color   color.NRGBA
20959                                 Palette Texture
20960
20961                                 Waving       WaveType
20962                                 ConnectSides uint8
20963                                 ConnectTo    []Content
20964                                 InsideTint   color.NRGBA
20965                                 Level        uint8 // Must be < 128.
20966
20967                                 Translucent bool // Sunlight is scattered and becomes normal light.
20968                                 Transparent bool // Sunlight isn't scattered.
20969                                 LightSrc    uint8
20970
20971                                 GndContent   bool
20972                                 Collides     bool
20973                                 Pointable    bool
20974                                 Diggable     bool
20975                                 Climbable    bool
20976                                 Replaceable  bool
20977                                 OnRightClick bool
20978
20979                                 DmgPerSec int32
20980
20981                                 LiquidType   LiquidType
20982                                 FlowingAlt   string
20983                                 SrcAlt       string
20984                                 Viscosity    uint8 // 0-7
20985                                 LiqRenewable bool
20986                                 FlowRange    uint8
20987                                 DrownDmg     uint8
20988                                 Floodable    bool
20989
20990                                 DrawBox, ColBox, SelBox NodeBox
20991
20992                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
20993
20994                                 LegacyFaceDir bool
20995                                 LegacyMounted bool
20996
20997                                 DigPredict string
20998
20999                                 MaxLvl uint8
21000
21001                                 AlphaUse
21002
21003                                 MoveResistance uint8
21004
21005                                 LiquidMovePhysics bool
21006                         }))(obj)).Level
21007                         *p = read8(r)
21008                 }
21009                 {
21010                         p := &(*(*(struct {
21011                                 Param0 Content
21012
21013                                 Name   string
21014                                 Groups []Group
21015
21016                                 P1Type   Param1Type
21017                                 P2Type   Param2Type
21018                                 DrawType DrawType
21019
21020                                 Mesh  string
21021                                 Scale float32
21022                                 //mt:const uint8(6)
21023                                 Tiles        [6]TileDef
21024                                 OverlayTiles [6]TileDef
21025                                 //mt:const uint8(6)
21026                                 SpecialTiles [6]TileDef
21027
21028                                 Color   color.NRGBA
21029                                 Palette Texture
21030
21031                                 Waving       WaveType
21032                                 ConnectSides uint8
21033                                 ConnectTo    []Content
21034                                 InsideTint   color.NRGBA
21035                                 Level        uint8 // Must be < 128.
21036
21037                                 Translucent bool // Sunlight is scattered and becomes normal light.
21038                                 Transparent bool // Sunlight isn't scattered.
21039                                 LightSrc    uint8
21040
21041                                 GndContent   bool
21042                                 Collides     bool
21043                                 Pointable    bool
21044                                 Diggable     bool
21045                                 Climbable    bool
21046                                 Replaceable  bool
21047                                 OnRightClick bool
21048
21049                                 DmgPerSec int32
21050
21051                                 LiquidType   LiquidType
21052                                 FlowingAlt   string
21053                                 SrcAlt       string
21054                                 Viscosity    uint8 // 0-7
21055                                 LiqRenewable bool
21056                                 FlowRange    uint8
21057                                 DrownDmg     uint8
21058                                 Floodable    bool
21059
21060                                 DrawBox, ColBox, SelBox NodeBox
21061
21062                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21063
21064                                 LegacyFaceDir bool
21065                                 LegacyMounted bool
21066
21067                                 DigPredict string
21068
21069                                 MaxLvl uint8
21070
21071                                 AlphaUse
21072
21073                                 MoveResistance uint8
21074
21075                                 LiquidMovePhysics bool
21076                         }))(obj)).Translucent
21077                         switch n := read8(r); n {
21078                         case 0:
21079                                 *p = false
21080                         case 1:
21081                                 *p = true
21082                         default:
21083                                 chk(fmt.Errorf("invalid bool: %d", n))
21084                         }
21085                 }
21086                 {
21087                         p := &(*(*(struct {
21088                                 Param0 Content
21089
21090                                 Name   string
21091                                 Groups []Group
21092
21093                                 P1Type   Param1Type
21094                                 P2Type   Param2Type
21095                                 DrawType DrawType
21096
21097                                 Mesh  string
21098                                 Scale float32
21099                                 //mt:const uint8(6)
21100                                 Tiles        [6]TileDef
21101                                 OverlayTiles [6]TileDef
21102                                 //mt:const uint8(6)
21103                                 SpecialTiles [6]TileDef
21104
21105                                 Color   color.NRGBA
21106                                 Palette Texture
21107
21108                                 Waving       WaveType
21109                                 ConnectSides uint8
21110                                 ConnectTo    []Content
21111                                 InsideTint   color.NRGBA
21112                                 Level        uint8 // Must be < 128.
21113
21114                                 Translucent bool // Sunlight is scattered and becomes normal light.
21115                                 Transparent bool // Sunlight isn't scattered.
21116                                 LightSrc    uint8
21117
21118                                 GndContent   bool
21119                                 Collides     bool
21120                                 Pointable    bool
21121                                 Diggable     bool
21122                                 Climbable    bool
21123                                 Replaceable  bool
21124                                 OnRightClick bool
21125
21126                                 DmgPerSec int32
21127
21128                                 LiquidType   LiquidType
21129                                 FlowingAlt   string
21130                                 SrcAlt       string
21131                                 Viscosity    uint8 // 0-7
21132                                 LiqRenewable bool
21133                                 FlowRange    uint8
21134                                 DrownDmg     uint8
21135                                 Floodable    bool
21136
21137                                 DrawBox, ColBox, SelBox NodeBox
21138
21139                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21140
21141                                 LegacyFaceDir bool
21142                                 LegacyMounted bool
21143
21144                                 DigPredict string
21145
21146                                 MaxLvl uint8
21147
21148                                 AlphaUse
21149
21150                                 MoveResistance uint8
21151
21152                                 LiquidMovePhysics bool
21153                         }))(obj)).Transparent
21154                         switch n := read8(r); n {
21155                         case 0:
21156                                 *p = false
21157                         case 1:
21158                                 *p = true
21159                         default:
21160                                 chk(fmt.Errorf("invalid bool: %d", n))
21161                         }
21162                 }
21163                 {
21164                         p := &(*(*(struct {
21165                                 Param0 Content
21166
21167                                 Name   string
21168                                 Groups []Group
21169
21170                                 P1Type   Param1Type
21171                                 P2Type   Param2Type
21172                                 DrawType DrawType
21173
21174                                 Mesh  string
21175                                 Scale float32
21176                                 //mt:const uint8(6)
21177                                 Tiles        [6]TileDef
21178                                 OverlayTiles [6]TileDef
21179                                 //mt:const uint8(6)
21180                                 SpecialTiles [6]TileDef
21181
21182                                 Color   color.NRGBA
21183                                 Palette Texture
21184
21185                                 Waving       WaveType
21186                                 ConnectSides uint8
21187                                 ConnectTo    []Content
21188                                 InsideTint   color.NRGBA
21189                                 Level        uint8 // Must be < 128.
21190
21191                                 Translucent bool // Sunlight is scattered and becomes normal light.
21192                                 Transparent bool // Sunlight isn't scattered.
21193                                 LightSrc    uint8
21194
21195                                 GndContent   bool
21196                                 Collides     bool
21197                                 Pointable    bool
21198                                 Diggable     bool
21199                                 Climbable    bool
21200                                 Replaceable  bool
21201                                 OnRightClick bool
21202
21203                                 DmgPerSec int32
21204
21205                                 LiquidType   LiquidType
21206                                 FlowingAlt   string
21207                                 SrcAlt       string
21208                                 Viscosity    uint8 // 0-7
21209                                 LiqRenewable bool
21210                                 FlowRange    uint8
21211                                 DrownDmg     uint8
21212                                 Floodable    bool
21213
21214                                 DrawBox, ColBox, SelBox NodeBox
21215
21216                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21217
21218                                 LegacyFaceDir bool
21219                                 LegacyMounted bool
21220
21221                                 DigPredict string
21222
21223                                 MaxLvl uint8
21224
21225                                 AlphaUse
21226
21227                                 MoveResistance uint8
21228
21229                                 LiquidMovePhysics bool
21230                         }))(obj)).LightSrc
21231                         *p = read8(r)
21232                 }
21233                 {
21234                         p := &(*(*(struct {
21235                                 Param0 Content
21236
21237                                 Name   string
21238                                 Groups []Group
21239
21240                                 P1Type   Param1Type
21241                                 P2Type   Param2Type
21242                                 DrawType DrawType
21243
21244                                 Mesh  string
21245                                 Scale float32
21246                                 //mt:const uint8(6)
21247                                 Tiles        [6]TileDef
21248                                 OverlayTiles [6]TileDef
21249                                 //mt:const uint8(6)
21250                                 SpecialTiles [6]TileDef
21251
21252                                 Color   color.NRGBA
21253                                 Palette Texture
21254
21255                                 Waving       WaveType
21256                                 ConnectSides uint8
21257                                 ConnectTo    []Content
21258                                 InsideTint   color.NRGBA
21259                                 Level        uint8 // Must be < 128.
21260
21261                                 Translucent bool // Sunlight is scattered and becomes normal light.
21262                                 Transparent bool // Sunlight isn't scattered.
21263                                 LightSrc    uint8
21264
21265                                 GndContent   bool
21266                                 Collides     bool
21267                                 Pointable    bool
21268                                 Diggable     bool
21269                                 Climbable    bool
21270                                 Replaceable  bool
21271                                 OnRightClick bool
21272
21273                                 DmgPerSec int32
21274
21275                                 LiquidType   LiquidType
21276                                 FlowingAlt   string
21277                                 SrcAlt       string
21278                                 Viscosity    uint8 // 0-7
21279                                 LiqRenewable bool
21280                                 FlowRange    uint8
21281                                 DrownDmg     uint8
21282                                 Floodable    bool
21283
21284                                 DrawBox, ColBox, SelBox NodeBox
21285
21286                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21287
21288                                 LegacyFaceDir bool
21289                                 LegacyMounted bool
21290
21291                                 DigPredict string
21292
21293                                 MaxLvl uint8
21294
21295                                 AlphaUse
21296
21297                                 MoveResistance uint8
21298
21299                                 LiquidMovePhysics bool
21300                         }))(obj)).GndContent
21301                         switch n := read8(r); n {
21302                         case 0:
21303                                 *p = false
21304                         case 1:
21305                                 *p = true
21306                         default:
21307                                 chk(fmt.Errorf("invalid bool: %d", n))
21308                         }
21309                 }
21310                 {
21311                         p := &(*(*(struct {
21312                                 Param0 Content
21313
21314                                 Name   string
21315                                 Groups []Group
21316
21317                                 P1Type   Param1Type
21318                                 P2Type   Param2Type
21319                                 DrawType DrawType
21320
21321                                 Mesh  string
21322                                 Scale float32
21323                                 //mt:const uint8(6)
21324                                 Tiles        [6]TileDef
21325                                 OverlayTiles [6]TileDef
21326                                 //mt:const uint8(6)
21327                                 SpecialTiles [6]TileDef
21328
21329                                 Color   color.NRGBA
21330                                 Palette Texture
21331
21332                                 Waving       WaveType
21333                                 ConnectSides uint8
21334                                 ConnectTo    []Content
21335                                 InsideTint   color.NRGBA
21336                                 Level        uint8 // Must be < 128.
21337
21338                                 Translucent bool // Sunlight is scattered and becomes normal light.
21339                                 Transparent bool // Sunlight isn't scattered.
21340                                 LightSrc    uint8
21341
21342                                 GndContent   bool
21343                                 Collides     bool
21344                                 Pointable    bool
21345                                 Diggable     bool
21346                                 Climbable    bool
21347                                 Replaceable  bool
21348                                 OnRightClick bool
21349
21350                                 DmgPerSec int32
21351
21352                                 LiquidType   LiquidType
21353                                 FlowingAlt   string
21354                                 SrcAlt       string
21355                                 Viscosity    uint8 // 0-7
21356                                 LiqRenewable bool
21357                                 FlowRange    uint8
21358                                 DrownDmg     uint8
21359                                 Floodable    bool
21360
21361                                 DrawBox, ColBox, SelBox NodeBox
21362
21363                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21364
21365                                 LegacyFaceDir bool
21366                                 LegacyMounted bool
21367
21368                                 DigPredict string
21369
21370                                 MaxLvl uint8
21371
21372                                 AlphaUse
21373
21374                                 MoveResistance uint8
21375
21376                                 LiquidMovePhysics bool
21377                         }))(obj)).Collides
21378                         switch n := read8(r); n {
21379                         case 0:
21380                                 *p = false
21381                         case 1:
21382                                 *p = true
21383                         default:
21384                                 chk(fmt.Errorf("invalid bool: %d", n))
21385                         }
21386                 }
21387                 {
21388                         p := &(*(*(struct {
21389                                 Param0 Content
21390
21391                                 Name   string
21392                                 Groups []Group
21393
21394                                 P1Type   Param1Type
21395                                 P2Type   Param2Type
21396                                 DrawType DrawType
21397
21398                                 Mesh  string
21399                                 Scale float32
21400                                 //mt:const uint8(6)
21401                                 Tiles        [6]TileDef
21402                                 OverlayTiles [6]TileDef
21403                                 //mt:const uint8(6)
21404                                 SpecialTiles [6]TileDef
21405
21406                                 Color   color.NRGBA
21407                                 Palette Texture
21408
21409                                 Waving       WaveType
21410                                 ConnectSides uint8
21411                                 ConnectTo    []Content
21412                                 InsideTint   color.NRGBA
21413                                 Level        uint8 // Must be < 128.
21414
21415                                 Translucent bool // Sunlight is scattered and becomes normal light.
21416                                 Transparent bool // Sunlight isn't scattered.
21417                                 LightSrc    uint8
21418
21419                                 GndContent   bool
21420                                 Collides     bool
21421                                 Pointable    bool
21422                                 Diggable     bool
21423                                 Climbable    bool
21424                                 Replaceable  bool
21425                                 OnRightClick bool
21426
21427                                 DmgPerSec int32
21428
21429                                 LiquidType   LiquidType
21430                                 FlowingAlt   string
21431                                 SrcAlt       string
21432                                 Viscosity    uint8 // 0-7
21433                                 LiqRenewable bool
21434                                 FlowRange    uint8
21435                                 DrownDmg     uint8
21436                                 Floodable    bool
21437
21438                                 DrawBox, ColBox, SelBox NodeBox
21439
21440                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21441
21442                                 LegacyFaceDir bool
21443                                 LegacyMounted bool
21444
21445                                 DigPredict string
21446
21447                                 MaxLvl uint8
21448
21449                                 AlphaUse
21450
21451                                 MoveResistance uint8
21452
21453                                 LiquidMovePhysics bool
21454                         }))(obj)).Pointable
21455                         switch n := read8(r); n {
21456                         case 0:
21457                                 *p = false
21458                         case 1:
21459                                 *p = true
21460                         default:
21461                                 chk(fmt.Errorf("invalid bool: %d", n))
21462                         }
21463                 }
21464                 {
21465                         p := &(*(*(struct {
21466                                 Param0 Content
21467
21468                                 Name   string
21469                                 Groups []Group
21470
21471                                 P1Type   Param1Type
21472                                 P2Type   Param2Type
21473                                 DrawType DrawType
21474
21475                                 Mesh  string
21476                                 Scale float32
21477                                 //mt:const uint8(6)
21478                                 Tiles        [6]TileDef
21479                                 OverlayTiles [6]TileDef
21480                                 //mt:const uint8(6)
21481                                 SpecialTiles [6]TileDef
21482
21483                                 Color   color.NRGBA
21484                                 Palette Texture
21485
21486                                 Waving       WaveType
21487                                 ConnectSides uint8
21488                                 ConnectTo    []Content
21489                                 InsideTint   color.NRGBA
21490                                 Level        uint8 // Must be < 128.
21491
21492                                 Translucent bool // Sunlight is scattered and becomes normal light.
21493                                 Transparent bool // Sunlight isn't scattered.
21494                                 LightSrc    uint8
21495
21496                                 GndContent   bool
21497                                 Collides     bool
21498                                 Pointable    bool
21499                                 Diggable     bool
21500                                 Climbable    bool
21501                                 Replaceable  bool
21502                                 OnRightClick bool
21503
21504                                 DmgPerSec int32
21505
21506                                 LiquidType   LiquidType
21507                                 FlowingAlt   string
21508                                 SrcAlt       string
21509                                 Viscosity    uint8 // 0-7
21510                                 LiqRenewable bool
21511                                 FlowRange    uint8
21512                                 DrownDmg     uint8
21513                                 Floodable    bool
21514
21515                                 DrawBox, ColBox, SelBox NodeBox
21516
21517                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21518
21519                                 LegacyFaceDir bool
21520                                 LegacyMounted bool
21521
21522                                 DigPredict string
21523
21524                                 MaxLvl uint8
21525
21526                                 AlphaUse
21527
21528                                 MoveResistance uint8
21529
21530                                 LiquidMovePhysics bool
21531                         }))(obj)).Diggable
21532                         switch n := read8(r); n {
21533                         case 0:
21534                                 *p = false
21535                         case 1:
21536                                 *p = true
21537                         default:
21538                                 chk(fmt.Errorf("invalid bool: %d", n))
21539                         }
21540                 }
21541                 {
21542                         p := &(*(*(struct {
21543                                 Param0 Content
21544
21545                                 Name   string
21546                                 Groups []Group
21547
21548                                 P1Type   Param1Type
21549                                 P2Type   Param2Type
21550                                 DrawType DrawType
21551
21552                                 Mesh  string
21553                                 Scale float32
21554                                 //mt:const uint8(6)
21555                                 Tiles        [6]TileDef
21556                                 OverlayTiles [6]TileDef
21557                                 //mt:const uint8(6)
21558                                 SpecialTiles [6]TileDef
21559
21560                                 Color   color.NRGBA
21561                                 Palette Texture
21562
21563                                 Waving       WaveType
21564                                 ConnectSides uint8
21565                                 ConnectTo    []Content
21566                                 InsideTint   color.NRGBA
21567                                 Level        uint8 // Must be < 128.
21568
21569                                 Translucent bool // Sunlight is scattered and becomes normal light.
21570                                 Transparent bool // Sunlight isn't scattered.
21571                                 LightSrc    uint8
21572
21573                                 GndContent   bool
21574                                 Collides     bool
21575                                 Pointable    bool
21576                                 Diggable     bool
21577                                 Climbable    bool
21578                                 Replaceable  bool
21579                                 OnRightClick bool
21580
21581                                 DmgPerSec int32
21582
21583                                 LiquidType   LiquidType
21584                                 FlowingAlt   string
21585                                 SrcAlt       string
21586                                 Viscosity    uint8 // 0-7
21587                                 LiqRenewable bool
21588                                 FlowRange    uint8
21589                                 DrownDmg     uint8
21590                                 Floodable    bool
21591
21592                                 DrawBox, ColBox, SelBox NodeBox
21593
21594                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21595
21596                                 LegacyFaceDir bool
21597                                 LegacyMounted bool
21598
21599                                 DigPredict string
21600
21601                                 MaxLvl uint8
21602
21603                                 AlphaUse
21604
21605                                 MoveResistance uint8
21606
21607                                 LiquidMovePhysics bool
21608                         }))(obj)).Climbable
21609                         switch n := read8(r); n {
21610                         case 0:
21611                                 *p = false
21612                         case 1:
21613                                 *p = true
21614                         default:
21615                                 chk(fmt.Errorf("invalid bool: %d", n))
21616                         }
21617                 }
21618                 {
21619                         p := &(*(*(struct {
21620                                 Param0 Content
21621
21622                                 Name   string
21623                                 Groups []Group
21624
21625                                 P1Type   Param1Type
21626                                 P2Type   Param2Type
21627                                 DrawType DrawType
21628
21629                                 Mesh  string
21630                                 Scale float32
21631                                 //mt:const uint8(6)
21632                                 Tiles        [6]TileDef
21633                                 OverlayTiles [6]TileDef
21634                                 //mt:const uint8(6)
21635                                 SpecialTiles [6]TileDef
21636
21637                                 Color   color.NRGBA
21638                                 Palette Texture
21639
21640                                 Waving       WaveType
21641                                 ConnectSides uint8
21642                                 ConnectTo    []Content
21643                                 InsideTint   color.NRGBA
21644                                 Level        uint8 // Must be < 128.
21645
21646                                 Translucent bool // Sunlight is scattered and becomes normal light.
21647                                 Transparent bool // Sunlight isn't scattered.
21648                                 LightSrc    uint8
21649
21650                                 GndContent   bool
21651                                 Collides     bool
21652                                 Pointable    bool
21653                                 Diggable     bool
21654                                 Climbable    bool
21655                                 Replaceable  bool
21656                                 OnRightClick bool
21657
21658                                 DmgPerSec int32
21659
21660                                 LiquidType   LiquidType
21661                                 FlowingAlt   string
21662                                 SrcAlt       string
21663                                 Viscosity    uint8 // 0-7
21664                                 LiqRenewable bool
21665                                 FlowRange    uint8
21666                                 DrownDmg     uint8
21667                                 Floodable    bool
21668
21669                                 DrawBox, ColBox, SelBox NodeBox
21670
21671                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21672
21673                                 LegacyFaceDir bool
21674                                 LegacyMounted bool
21675
21676                                 DigPredict string
21677
21678                                 MaxLvl uint8
21679
21680                                 AlphaUse
21681
21682                                 MoveResistance uint8
21683
21684                                 LiquidMovePhysics bool
21685                         }))(obj)).Replaceable
21686                         switch n := read8(r); n {
21687                         case 0:
21688                                 *p = false
21689                         case 1:
21690                                 *p = true
21691                         default:
21692                                 chk(fmt.Errorf("invalid bool: %d", n))
21693                         }
21694                 }
21695                 {
21696                         p := &(*(*(struct {
21697                                 Param0 Content
21698
21699                                 Name   string
21700                                 Groups []Group
21701
21702                                 P1Type   Param1Type
21703                                 P2Type   Param2Type
21704                                 DrawType DrawType
21705
21706                                 Mesh  string
21707                                 Scale float32
21708                                 //mt:const uint8(6)
21709                                 Tiles        [6]TileDef
21710                                 OverlayTiles [6]TileDef
21711                                 //mt:const uint8(6)
21712                                 SpecialTiles [6]TileDef
21713
21714                                 Color   color.NRGBA
21715                                 Palette Texture
21716
21717                                 Waving       WaveType
21718                                 ConnectSides uint8
21719                                 ConnectTo    []Content
21720                                 InsideTint   color.NRGBA
21721                                 Level        uint8 // Must be < 128.
21722
21723                                 Translucent bool // Sunlight is scattered and becomes normal light.
21724                                 Transparent bool // Sunlight isn't scattered.
21725                                 LightSrc    uint8
21726
21727                                 GndContent   bool
21728                                 Collides     bool
21729                                 Pointable    bool
21730                                 Diggable     bool
21731                                 Climbable    bool
21732                                 Replaceable  bool
21733                                 OnRightClick bool
21734
21735                                 DmgPerSec int32
21736
21737                                 LiquidType   LiquidType
21738                                 FlowingAlt   string
21739                                 SrcAlt       string
21740                                 Viscosity    uint8 // 0-7
21741                                 LiqRenewable bool
21742                                 FlowRange    uint8
21743                                 DrownDmg     uint8
21744                                 Floodable    bool
21745
21746                                 DrawBox, ColBox, SelBox NodeBox
21747
21748                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21749
21750                                 LegacyFaceDir bool
21751                                 LegacyMounted bool
21752
21753                                 DigPredict string
21754
21755                                 MaxLvl uint8
21756
21757                                 AlphaUse
21758
21759                                 MoveResistance uint8
21760
21761                                 LiquidMovePhysics bool
21762                         }))(obj)).OnRightClick
21763                         switch n := read8(r); n {
21764                         case 0:
21765                                 *p = false
21766                         case 1:
21767                                 *p = true
21768                         default:
21769                                 chk(fmt.Errorf("invalid bool: %d", n))
21770                         }
21771                 }
21772                 {
21773                         p := &(*(*(struct {
21774                                 Param0 Content
21775
21776                                 Name   string
21777                                 Groups []Group
21778
21779                                 P1Type   Param1Type
21780                                 P2Type   Param2Type
21781                                 DrawType DrawType
21782
21783                                 Mesh  string
21784                                 Scale float32
21785                                 //mt:const uint8(6)
21786                                 Tiles        [6]TileDef
21787                                 OverlayTiles [6]TileDef
21788                                 //mt:const uint8(6)
21789                                 SpecialTiles [6]TileDef
21790
21791                                 Color   color.NRGBA
21792                                 Palette Texture
21793
21794                                 Waving       WaveType
21795                                 ConnectSides uint8
21796                                 ConnectTo    []Content
21797                                 InsideTint   color.NRGBA
21798                                 Level        uint8 // Must be < 128.
21799
21800                                 Translucent bool // Sunlight is scattered and becomes normal light.
21801                                 Transparent bool // Sunlight isn't scattered.
21802                                 LightSrc    uint8
21803
21804                                 GndContent   bool
21805                                 Collides     bool
21806                                 Pointable    bool
21807                                 Diggable     bool
21808                                 Climbable    bool
21809                                 Replaceable  bool
21810                                 OnRightClick bool
21811
21812                                 DmgPerSec int32
21813
21814                                 LiquidType   LiquidType
21815                                 FlowingAlt   string
21816                                 SrcAlt       string
21817                                 Viscosity    uint8 // 0-7
21818                                 LiqRenewable bool
21819                                 FlowRange    uint8
21820                                 DrownDmg     uint8
21821                                 Floodable    bool
21822
21823                                 DrawBox, ColBox, SelBox NodeBox
21824
21825                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21826
21827                                 LegacyFaceDir bool
21828                                 LegacyMounted bool
21829
21830                                 DigPredict string
21831
21832                                 MaxLvl uint8
21833
21834                                 AlphaUse
21835
21836                                 MoveResistance uint8
21837
21838                                 LiquidMovePhysics bool
21839                         }))(obj)).DmgPerSec
21840                         *p = int32(read32(r))
21841                 }
21842                 if err := pcall(func() {
21843                         ((*(*(struct {
21844                                 Param0 Content
21845
21846                                 Name   string
21847                                 Groups []Group
21848
21849                                 P1Type   Param1Type
21850                                 P2Type   Param2Type
21851                                 DrawType DrawType
21852
21853                                 Mesh  string
21854                                 Scale float32
21855                                 //mt:const uint8(6)
21856                                 Tiles        [6]TileDef
21857                                 OverlayTiles [6]TileDef
21858                                 //mt:const uint8(6)
21859                                 SpecialTiles [6]TileDef
21860
21861                                 Color   color.NRGBA
21862                                 Palette Texture
21863
21864                                 Waving       WaveType
21865                                 ConnectSides uint8
21866                                 ConnectTo    []Content
21867                                 InsideTint   color.NRGBA
21868                                 Level        uint8 // Must be < 128.
21869
21870                                 Translucent bool // Sunlight is scattered and becomes normal light.
21871                                 Transparent bool // Sunlight isn't scattered.
21872                                 LightSrc    uint8
21873
21874                                 GndContent   bool
21875                                 Collides     bool
21876                                 Pointable    bool
21877                                 Diggable     bool
21878                                 Climbable    bool
21879                                 Replaceable  bool
21880                                 OnRightClick bool
21881
21882                                 DmgPerSec int32
21883
21884                                 LiquidType   LiquidType
21885                                 FlowingAlt   string
21886                                 SrcAlt       string
21887                                 Viscosity    uint8 // 0-7
21888                                 LiqRenewable bool
21889                                 FlowRange    uint8
21890                                 DrownDmg     uint8
21891                                 Floodable    bool
21892
21893                                 DrawBox, ColBox, SelBox NodeBox
21894
21895                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
21896
21897                                 LegacyFaceDir bool
21898                                 LegacyMounted bool
21899
21900                                 DigPredict string
21901
21902                                 MaxLvl uint8
21903
21904                                 AlphaUse
21905
21906                                 MoveResistance uint8
21907
21908                                 LiquidMovePhysics bool
21909                         }))(obj)).LiquidType).deserialize(r)
21910                 }); err != nil {
21911                         if err == io.EOF {
21912                                 chk(io.EOF)
21913                         }
21914                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LiquidType", err))
21915                 }
21916                 var local263 []uint8
21917                 var local264 uint16
21918                 {
21919                         p := &local264
21920                         *p = read16(r)
21921                 }
21922                 (local263) = make([]uint8, local264)
21923                 {
21924                         _, err := io.ReadFull(r, (local263)[:])
21925                         chk(err)
21926                 }
21927                 ((*(*(struct {
21928                         Param0 Content
21929
21930                         Name   string
21931                         Groups []Group
21932
21933                         P1Type   Param1Type
21934                         P2Type   Param2Type
21935                         DrawType DrawType
21936
21937                         Mesh  string
21938                         Scale float32
21939                         //mt:const uint8(6)
21940                         Tiles        [6]TileDef
21941                         OverlayTiles [6]TileDef
21942                         //mt:const uint8(6)
21943                         SpecialTiles [6]TileDef
21944
21945                         Color   color.NRGBA
21946                         Palette Texture
21947
21948                         Waving       WaveType
21949                         ConnectSides uint8
21950                         ConnectTo    []Content
21951                         InsideTint   color.NRGBA
21952                         Level        uint8 // Must be < 128.
21953
21954                         Translucent bool // Sunlight is scattered and becomes normal light.
21955                         Transparent bool // Sunlight isn't scattered.
21956                         LightSrc    uint8
21957
21958                         GndContent   bool
21959                         Collides     bool
21960                         Pointable    bool
21961                         Diggable     bool
21962                         Climbable    bool
21963                         Replaceable  bool
21964                         OnRightClick bool
21965
21966                         DmgPerSec int32
21967
21968                         LiquidType   LiquidType
21969                         FlowingAlt   string
21970                         SrcAlt       string
21971                         Viscosity    uint8 // 0-7
21972                         LiqRenewable bool
21973                         FlowRange    uint8
21974                         DrownDmg     uint8
21975                         Floodable    bool
21976
21977                         DrawBox, ColBox, SelBox NodeBox
21978
21979                         FootstepSnd, DiggingSnd, DugSnd SoundDef
21980
21981                         LegacyFaceDir bool
21982                         LegacyMounted bool
21983
21984                         DigPredict string
21985
21986                         MaxLvl uint8
21987
21988                         AlphaUse
21989
21990                         MoveResistance uint8
21991
21992                         LiquidMovePhysics bool
21993                 }))(obj)).FlowingAlt) = string(local263)
21994                 var local265 []uint8
21995                 var local266 uint16
21996                 {
21997                         p := &local266
21998                         *p = read16(r)
21999                 }
22000                 (local265) = make([]uint8, local266)
22001                 {
22002                         _, err := io.ReadFull(r, (local265)[:])
22003                         chk(err)
22004                 }
22005                 ((*(*(struct {
22006                         Param0 Content
22007
22008                         Name   string
22009                         Groups []Group
22010
22011                         P1Type   Param1Type
22012                         P2Type   Param2Type
22013                         DrawType DrawType
22014
22015                         Mesh  string
22016                         Scale float32
22017                         //mt:const uint8(6)
22018                         Tiles        [6]TileDef
22019                         OverlayTiles [6]TileDef
22020                         //mt:const uint8(6)
22021                         SpecialTiles [6]TileDef
22022
22023                         Color   color.NRGBA
22024                         Palette Texture
22025
22026                         Waving       WaveType
22027                         ConnectSides uint8
22028                         ConnectTo    []Content
22029                         InsideTint   color.NRGBA
22030                         Level        uint8 // Must be < 128.
22031
22032                         Translucent bool // Sunlight is scattered and becomes normal light.
22033                         Transparent bool // Sunlight isn't scattered.
22034                         LightSrc    uint8
22035
22036                         GndContent   bool
22037                         Collides     bool
22038                         Pointable    bool
22039                         Diggable     bool
22040                         Climbable    bool
22041                         Replaceable  bool
22042                         OnRightClick bool
22043
22044                         DmgPerSec int32
22045
22046                         LiquidType   LiquidType
22047                         FlowingAlt   string
22048                         SrcAlt       string
22049                         Viscosity    uint8 // 0-7
22050                         LiqRenewable bool
22051                         FlowRange    uint8
22052                         DrownDmg     uint8
22053                         Floodable    bool
22054
22055                         DrawBox, ColBox, SelBox NodeBox
22056
22057                         FootstepSnd, DiggingSnd, DugSnd SoundDef
22058
22059                         LegacyFaceDir bool
22060                         LegacyMounted bool
22061
22062                         DigPredict string
22063
22064                         MaxLvl uint8
22065
22066                         AlphaUse
22067
22068                         MoveResistance uint8
22069
22070                         LiquidMovePhysics bool
22071                 }))(obj)).SrcAlt) = string(local265)
22072                 {
22073                         p := &(*(*(struct {
22074                                 Param0 Content
22075
22076                                 Name   string
22077                                 Groups []Group
22078
22079                                 P1Type   Param1Type
22080                                 P2Type   Param2Type
22081                                 DrawType DrawType
22082
22083                                 Mesh  string
22084                                 Scale float32
22085                                 //mt:const uint8(6)
22086                                 Tiles        [6]TileDef
22087                                 OverlayTiles [6]TileDef
22088                                 //mt:const uint8(6)
22089                                 SpecialTiles [6]TileDef
22090
22091                                 Color   color.NRGBA
22092                                 Palette Texture
22093
22094                                 Waving       WaveType
22095                                 ConnectSides uint8
22096                                 ConnectTo    []Content
22097                                 InsideTint   color.NRGBA
22098                                 Level        uint8 // Must be < 128.
22099
22100                                 Translucent bool // Sunlight is scattered and becomes normal light.
22101                                 Transparent bool // Sunlight isn't scattered.
22102                                 LightSrc    uint8
22103
22104                                 GndContent   bool
22105                                 Collides     bool
22106                                 Pointable    bool
22107                                 Diggable     bool
22108                                 Climbable    bool
22109                                 Replaceable  bool
22110                                 OnRightClick bool
22111
22112                                 DmgPerSec int32
22113
22114                                 LiquidType   LiquidType
22115                                 FlowingAlt   string
22116                                 SrcAlt       string
22117                                 Viscosity    uint8 // 0-7
22118                                 LiqRenewable bool
22119                                 FlowRange    uint8
22120                                 DrownDmg     uint8
22121                                 Floodable    bool
22122
22123                                 DrawBox, ColBox, SelBox NodeBox
22124
22125                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22126
22127                                 LegacyFaceDir bool
22128                                 LegacyMounted bool
22129
22130                                 DigPredict string
22131
22132                                 MaxLvl uint8
22133
22134                                 AlphaUse
22135
22136                                 MoveResistance uint8
22137
22138                                 LiquidMovePhysics bool
22139                         }))(obj)).Viscosity
22140                         *p = read8(r)
22141                 }
22142                 {
22143                         p := &(*(*(struct {
22144                                 Param0 Content
22145
22146                                 Name   string
22147                                 Groups []Group
22148
22149                                 P1Type   Param1Type
22150                                 P2Type   Param2Type
22151                                 DrawType DrawType
22152
22153                                 Mesh  string
22154                                 Scale float32
22155                                 //mt:const uint8(6)
22156                                 Tiles        [6]TileDef
22157                                 OverlayTiles [6]TileDef
22158                                 //mt:const uint8(6)
22159                                 SpecialTiles [6]TileDef
22160
22161                                 Color   color.NRGBA
22162                                 Palette Texture
22163
22164                                 Waving       WaveType
22165                                 ConnectSides uint8
22166                                 ConnectTo    []Content
22167                                 InsideTint   color.NRGBA
22168                                 Level        uint8 // Must be < 128.
22169
22170                                 Translucent bool // Sunlight is scattered and becomes normal light.
22171                                 Transparent bool // Sunlight isn't scattered.
22172                                 LightSrc    uint8
22173
22174                                 GndContent   bool
22175                                 Collides     bool
22176                                 Pointable    bool
22177                                 Diggable     bool
22178                                 Climbable    bool
22179                                 Replaceable  bool
22180                                 OnRightClick bool
22181
22182                                 DmgPerSec int32
22183
22184                                 LiquidType   LiquidType
22185                                 FlowingAlt   string
22186                                 SrcAlt       string
22187                                 Viscosity    uint8 // 0-7
22188                                 LiqRenewable bool
22189                                 FlowRange    uint8
22190                                 DrownDmg     uint8
22191                                 Floodable    bool
22192
22193                                 DrawBox, ColBox, SelBox NodeBox
22194
22195                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22196
22197                                 LegacyFaceDir bool
22198                                 LegacyMounted bool
22199
22200                                 DigPredict string
22201
22202                                 MaxLvl uint8
22203
22204                                 AlphaUse
22205
22206                                 MoveResistance uint8
22207
22208                                 LiquidMovePhysics bool
22209                         }))(obj)).LiqRenewable
22210                         switch n := read8(r); n {
22211                         case 0:
22212                                 *p = false
22213                         case 1:
22214                                 *p = true
22215                         default:
22216                                 chk(fmt.Errorf("invalid bool: %d", n))
22217                         }
22218                 }
22219                 {
22220                         p := &(*(*(struct {
22221                                 Param0 Content
22222
22223                                 Name   string
22224                                 Groups []Group
22225
22226                                 P1Type   Param1Type
22227                                 P2Type   Param2Type
22228                                 DrawType DrawType
22229
22230                                 Mesh  string
22231                                 Scale float32
22232                                 //mt:const uint8(6)
22233                                 Tiles        [6]TileDef
22234                                 OverlayTiles [6]TileDef
22235                                 //mt:const uint8(6)
22236                                 SpecialTiles [6]TileDef
22237
22238                                 Color   color.NRGBA
22239                                 Palette Texture
22240
22241                                 Waving       WaveType
22242                                 ConnectSides uint8
22243                                 ConnectTo    []Content
22244                                 InsideTint   color.NRGBA
22245                                 Level        uint8 // Must be < 128.
22246
22247                                 Translucent bool // Sunlight is scattered and becomes normal light.
22248                                 Transparent bool // Sunlight isn't scattered.
22249                                 LightSrc    uint8
22250
22251                                 GndContent   bool
22252                                 Collides     bool
22253                                 Pointable    bool
22254                                 Diggable     bool
22255                                 Climbable    bool
22256                                 Replaceable  bool
22257                                 OnRightClick bool
22258
22259                                 DmgPerSec int32
22260
22261                                 LiquidType   LiquidType
22262                                 FlowingAlt   string
22263                                 SrcAlt       string
22264                                 Viscosity    uint8 // 0-7
22265                                 LiqRenewable bool
22266                                 FlowRange    uint8
22267                                 DrownDmg     uint8
22268                                 Floodable    bool
22269
22270                                 DrawBox, ColBox, SelBox NodeBox
22271
22272                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22273
22274                                 LegacyFaceDir bool
22275                                 LegacyMounted bool
22276
22277                                 DigPredict string
22278
22279                                 MaxLvl uint8
22280
22281                                 AlphaUse
22282
22283                                 MoveResistance uint8
22284
22285                                 LiquidMovePhysics bool
22286                         }))(obj)).FlowRange
22287                         *p = read8(r)
22288                 }
22289                 {
22290                         p := &(*(*(struct {
22291                                 Param0 Content
22292
22293                                 Name   string
22294                                 Groups []Group
22295
22296                                 P1Type   Param1Type
22297                                 P2Type   Param2Type
22298                                 DrawType DrawType
22299
22300                                 Mesh  string
22301                                 Scale float32
22302                                 //mt:const uint8(6)
22303                                 Tiles        [6]TileDef
22304                                 OverlayTiles [6]TileDef
22305                                 //mt:const uint8(6)
22306                                 SpecialTiles [6]TileDef
22307
22308                                 Color   color.NRGBA
22309                                 Palette Texture
22310
22311                                 Waving       WaveType
22312                                 ConnectSides uint8
22313                                 ConnectTo    []Content
22314                                 InsideTint   color.NRGBA
22315                                 Level        uint8 // Must be < 128.
22316
22317                                 Translucent bool // Sunlight is scattered and becomes normal light.
22318                                 Transparent bool // Sunlight isn't scattered.
22319                                 LightSrc    uint8
22320
22321                                 GndContent   bool
22322                                 Collides     bool
22323                                 Pointable    bool
22324                                 Diggable     bool
22325                                 Climbable    bool
22326                                 Replaceable  bool
22327                                 OnRightClick bool
22328
22329                                 DmgPerSec int32
22330
22331                                 LiquidType   LiquidType
22332                                 FlowingAlt   string
22333                                 SrcAlt       string
22334                                 Viscosity    uint8 // 0-7
22335                                 LiqRenewable bool
22336                                 FlowRange    uint8
22337                                 DrownDmg     uint8
22338                                 Floodable    bool
22339
22340                                 DrawBox, ColBox, SelBox NodeBox
22341
22342                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22343
22344                                 LegacyFaceDir bool
22345                                 LegacyMounted bool
22346
22347                                 DigPredict string
22348
22349                                 MaxLvl uint8
22350
22351                                 AlphaUse
22352
22353                                 MoveResistance uint8
22354
22355                                 LiquidMovePhysics bool
22356                         }))(obj)).DrownDmg
22357                         *p = read8(r)
22358                 }
22359                 {
22360                         p := &(*(*(struct {
22361                                 Param0 Content
22362
22363                                 Name   string
22364                                 Groups []Group
22365
22366                                 P1Type   Param1Type
22367                                 P2Type   Param2Type
22368                                 DrawType DrawType
22369
22370                                 Mesh  string
22371                                 Scale float32
22372                                 //mt:const uint8(6)
22373                                 Tiles        [6]TileDef
22374                                 OverlayTiles [6]TileDef
22375                                 //mt:const uint8(6)
22376                                 SpecialTiles [6]TileDef
22377
22378                                 Color   color.NRGBA
22379                                 Palette Texture
22380
22381                                 Waving       WaveType
22382                                 ConnectSides uint8
22383                                 ConnectTo    []Content
22384                                 InsideTint   color.NRGBA
22385                                 Level        uint8 // Must be < 128.
22386
22387                                 Translucent bool // Sunlight is scattered and becomes normal light.
22388                                 Transparent bool // Sunlight isn't scattered.
22389                                 LightSrc    uint8
22390
22391                                 GndContent   bool
22392                                 Collides     bool
22393                                 Pointable    bool
22394                                 Diggable     bool
22395                                 Climbable    bool
22396                                 Replaceable  bool
22397                                 OnRightClick bool
22398
22399                                 DmgPerSec int32
22400
22401                                 LiquidType   LiquidType
22402                                 FlowingAlt   string
22403                                 SrcAlt       string
22404                                 Viscosity    uint8 // 0-7
22405                                 LiqRenewable bool
22406                                 FlowRange    uint8
22407                                 DrownDmg     uint8
22408                                 Floodable    bool
22409
22410                                 DrawBox, ColBox, SelBox NodeBox
22411
22412                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22413
22414                                 LegacyFaceDir bool
22415                                 LegacyMounted bool
22416
22417                                 DigPredict string
22418
22419                                 MaxLvl uint8
22420
22421                                 AlphaUse
22422
22423                                 MoveResistance uint8
22424
22425                                 LiquidMovePhysics bool
22426                         }))(obj)).Floodable
22427                         switch n := read8(r); n {
22428                         case 0:
22429                                 *p = false
22430                         case 1:
22431                                 *p = true
22432                         default:
22433                                 chk(fmt.Errorf("invalid bool: %d", n))
22434                         }
22435                 }
22436                 if err := pcall(func() {
22437                         ((*(*(struct {
22438                                 Param0 Content
22439
22440                                 Name   string
22441                                 Groups []Group
22442
22443                                 P1Type   Param1Type
22444                                 P2Type   Param2Type
22445                                 DrawType DrawType
22446
22447                                 Mesh  string
22448                                 Scale float32
22449                                 //mt:const uint8(6)
22450                                 Tiles        [6]TileDef
22451                                 OverlayTiles [6]TileDef
22452                                 //mt:const uint8(6)
22453                                 SpecialTiles [6]TileDef
22454
22455                                 Color   color.NRGBA
22456                                 Palette Texture
22457
22458                                 Waving       WaveType
22459                                 ConnectSides uint8
22460                                 ConnectTo    []Content
22461                                 InsideTint   color.NRGBA
22462                                 Level        uint8 // Must be < 128.
22463
22464                                 Translucent bool // Sunlight is scattered and becomes normal light.
22465                                 Transparent bool // Sunlight isn't scattered.
22466                                 LightSrc    uint8
22467
22468                                 GndContent   bool
22469                                 Collides     bool
22470                                 Pointable    bool
22471                                 Diggable     bool
22472                                 Climbable    bool
22473                                 Replaceable  bool
22474                                 OnRightClick bool
22475
22476                                 DmgPerSec int32
22477
22478                                 LiquidType   LiquidType
22479                                 FlowingAlt   string
22480                                 SrcAlt       string
22481                                 Viscosity    uint8 // 0-7
22482                                 LiqRenewable bool
22483                                 FlowRange    uint8
22484                                 DrownDmg     uint8
22485                                 Floodable    bool
22486
22487                                 DrawBox, ColBox, SelBox NodeBox
22488
22489                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22490
22491                                 LegacyFaceDir bool
22492                                 LegacyMounted bool
22493
22494                                 DigPredict string
22495
22496                                 MaxLvl uint8
22497
22498                                 AlphaUse
22499
22500                                 MoveResistance uint8
22501
22502                                 LiquidMovePhysics bool
22503                         }))(obj)).DrawBox).deserialize(r)
22504                 }); err != nil {
22505                         if err == io.EOF {
22506                                 chk(io.EOF)
22507                         }
22508                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22509                 }
22510                 if err := pcall(func() {
22511                         ((*(*(struct {
22512                                 Param0 Content
22513
22514                                 Name   string
22515                                 Groups []Group
22516
22517                                 P1Type   Param1Type
22518                                 P2Type   Param2Type
22519                                 DrawType DrawType
22520
22521                                 Mesh  string
22522                                 Scale float32
22523                                 //mt:const uint8(6)
22524                                 Tiles        [6]TileDef
22525                                 OverlayTiles [6]TileDef
22526                                 //mt:const uint8(6)
22527                                 SpecialTiles [6]TileDef
22528
22529                                 Color   color.NRGBA
22530                                 Palette Texture
22531
22532                                 Waving       WaveType
22533                                 ConnectSides uint8
22534                                 ConnectTo    []Content
22535                                 InsideTint   color.NRGBA
22536                                 Level        uint8 // Must be < 128.
22537
22538                                 Translucent bool // Sunlight is scattered and becomes normal light.
22539                                 Transparent bool // Sunlight isn't scattered.
22540                                 LightSrc    uint8
22541
22542                                 GndContent   bool
22543                                 Collides     bool
22544                                 Pointable    bool
22545                                 Diggable     bool
22546                                 Climbable    bool
22547                                 Replaceable  bool
22548                                 OnRightClick bool
22549
22550                                 DmgPerSec int32
22551
22552                                 LiquidType   LiquidType
22553                                 FlowingAlt   string
22554                                 SrcAlt       string
22555                                 Viscosity    uint8 // 0-7
22556                                 LiqRenewable bool
22557                                 FlowRange    uint8
22558                                 DrownDmg     uint8
22559                                 Floodable    bool
22560
22561                                 DrawBox, ColBox, SelBox NodeBox
22562
22563                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22564
22565                                 LegacyFaceDir bool
22566                                 LegacyMounted bool
22567
22568                                 DigPredict string
22569
22570                                 MaxLvl uint8
22571
22572                                 AlphaUse
22573
22574                                 MoveResistance uint8
22575
22576                                 LiquidMovePhysics bool
22577                         }))(obj)).ColBox).deserialize(r)
22578                 }); err != nil {
22579                         if err == io.EOF {
22580                                 chk(io.EOF)
22581                         }
22582                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22583                 }
22584                 if err := pcall(func() {
22585                         ((*(*(struct {
22586                                 Param0 Content
22587
22588                                 Name   string
22589                                 Groups []Group
22590
22591                                 P1Type   Param1Type
22592                                 P2Type   Param2Type
22593                                 DrawType DrawType
22594
22595                                 Mesh  string
22596                                 Scale float32
22597                                 //mt:const uint8(6)
22598                                 Tiles        [6]TileDef
22599                                 OverlayTiles [6]TileDef
22600                                 //mt:const uint8(6)
22601                                 SpecialTiles [6]TileDef
22602
22603                                 Color   color.NRGBA
22604                                 Palette Texture
22605
22606                                 Waving       WaveType
22607                                 ConnectSides uint8
22608                                 ConnectTo    []Content
22609                                 InsideTint   color.NRGBA
22610                                 Level        uint8 // Must be < 128.
22611
22612                                 Translucent bool // Sunlight is scattered and becomes normal light.
22613                                 Transparent bool // Sunlight isn't scattered.
22614                                 LightSrc    uint8
22615
22616                                 GndContent   bool
22617                                 Collides     bool
22618                                 Pointable    bool
22619                                 Diggable     bool
22620                                 Climbable    bool
22621                                 Replaceable  bool
22622                                 OnRightClick bool
22623
22624                                 DmgPerSec int32
22625
22626                                 LiquidType   LiquidType
22627                                 FlowingAlt   string
22628                                 SrcAlt       string
22629                                 Viscosity    uint8 // 0-7
22630                                 LiqRenewable bool
22631                                 FlowRange    uint8
22632                                 DrownDmg     uint8
22633                                 Floodable    bool
22634
22635                                 DrawBox, ColBox, SelBox NodeBox
22636
22637                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22638
22639                                 LegacyFaceDir bool
22640                                 LegacyMounted bool
22641
22642                                 DigPredict string
22643
22644                                 MaxLvl uint8
22645
22646                                 AlphaUse
22647
22648                                 MoveResistance uint8
22649
22650                                 LiquidMovePhysics bool
22651                         }))(obj)).SelBox).deserialize(r)
22652                 }); err != nil {
22653                         if err == io.EOF {
22654                                 chk(io.EOF)
22655                         }
22656                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBox", err))
22657                 }
22658                 if err := pcall(func() {
22659                         ((*(*(struct {
22660                                 Param0 Content
22661
22662                                 Name   string
22663                                 Groups []Group
22664
22665                                 P1Type   Param1Type
22666                                 P2Type   Param2Type
22667                                 DrawType DrawType
22668
22669                                 Mesh  string
22670                                 Scale float32
22671                                 //mt:const uint8(6)
22672                                 Tiles        [6]TileDef
22673                                 OverlayTiles [6]TileDef
22674                                 //mt:const uint8(6)
22675                                 SpecialTiles [6]TileDef
22676
22677                                 Color   color.NRGBA
22678                                 Palette Texture
22679
22680                                 Waving       WaveType
22681                                 ConnectSides uint8
22682                                 ConnectTo    []Content
22683                                 InsideTint   color.NRGBA
22684                                 Level        uint8 // Must be < 128.
22685
22686                                 Translucent bool // Sunlight is scattered and becomes normal light.
22687                                 Transparent bool // Sunlight isn't scattered.
22688                                 LightSrc    uint8
22689
22690                                 GndContent   bool
22691                                 Collides     bool
22692                                 Pointable    bool
22693                                 Diggable     bool
22694                                 Climbable    bool
22695                                 Replaceable  bool
22696                                 OnRightClick bool
22697
22698                                 DmgPerSec int32
22699
22700                                 LiquidType   LiquidType
22701                                 FlowingAlt   string
22702                                 SrcAlt       string
22703                                 Viscosity    uint8 // 0-7
22704                                 LiqRenewable bool
22705                                 FlowRange    uint8
22706                                 DrownDmg     uint8
22707                                 Floodable    bool
22708
22709                                 DrawBox, ColBox, SelBox NodeBox
22710
22711                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22712
22713                                 LegacyFaceDir bool
22714                                 LegacyMounted bool
22715
22716                                 DigPredict string
22717
22718                                 MaxLvl uint8
22719
22720                                 AlphaUse
22721
22722                                 MoveResistance uint8
22723
22724                                 LiquidMovePhysics bool
22725                         }))(obj)).FootstepSnd).deserialize(r)
22726                 }); err != nil {
22727                         if err == io.EOF {
22728                                 chk(io.EOF)
22729                         }
22730                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22731                 }
22732                 if err := pcall(func() {
22733                         ((*(*(struct {
22734                                 Param0 Content
22735
22736                                 Name   string
22737                                 Groups []Group
22738
22739                                 P1Type   Param1Type
22740                                 P2Type   Param2Type
22741                                 DrawType DrawType
22742
22743                                 Mesh  string
22744                                 Scale float32
22745                                 //mt:const uint8(6)
22746                                 Tiles        [6]TileDef
22747                                 OverlayTiles [6]TileDef
22748                                 //mt:const uint8(6)
22749                                 SpecialTiles [6]TileDef
22750
22751                                 Color   color.NRGBA
22752                                 Palette Texture
22753
22754                                 Waving       WaveType
22755                                 ConnectSides uint8
22756                                 ConnectTo    []Content
22757                                 InsideTint   color.NRGBA
22758                                 Level        uint8 // Must be < 128.
22759
22760                                 Translucent bool // Sunlight is scattered and becomes normal light.
22761                                 Transparent bool // Sunlight isn't scattered.
22762                                 LightSrc    uint8
22763
22764                                 GndContent   bool
22765                                 Collides     bool
22766                                 Pointable    bool
22767                                 Diggable     bool
22768                                 Climbable    bool
22769                                 Replaceable  bool
22770                                 OnRightClick bool
22771
22772                                 DmgPerSec int32
22773
22774                                 LiquidType   LiquidType
22775                                 FlowingAlt   string
22776                                 SrcAlt       string
22777                                 Viscosity    uint8 // 0-7
22778                                 LiqRenewable bool
22779                                 FlowRange    uint8
22780                                 DrownDmg     uint8
22781                                 Floodable    bool
22782
22783                                 DrawBox, ColBox, SelBox NodeBox
22784
22785                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22786
22787                                 LegacyFaceDir bool
22788                                 LegacyMounted bool
22789
22790                                 DigPredict string
22791
22792                                 MaxLvl uint8
22793
22794                                 AlphaUse
22795
22796                                 MoveResistance uint8
22797
22798                                 LiquidMovePhysics bool
22799                         }))(obj)).DiggingSnd).deserialize(r)
22800                 }); err != nil {
22801                         if err == io.EOF {
22802                                 chk(io.EOF)
22803                         }
22804                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22805                 }
22806                 if err := pcall(func() {
22807                         ((*(*(struct {
22808                                 Param0 Content
22809
22810                                 Name   string
22811                                 Groups []Group
22812
22813                                 P1Type   Param1Type
22814                                 P2Type   Param2Type
22815                                 DrawType DrawType
22816
22817                                 Mesh  string
22818                                 Scale float32
22819                                 //mt:const uint8(6)
22820                                 Tiles        [6]TileDef
22821                                 OverlayTiles [6]TileDef
22822                                 //mt:const uint8(6)
22823                                 SpecialTiles [6]TileDef
22824
22825                                 Color   color.NRGBA
22826                                 Palette Texture
22827
22828                                 Waving       WaveType
22829                                 ConnectSides uint8
22830                                 ConnectTo    []Content
22831                                 InsideTint   color.NRGBA
22832                                 Level        uint8 // Must be < 128.
22833
22834                                 Translucent bool // Sunlight is scattered and becomes normal light.
22835                                 Transparent bool // Sunlight isn't scattered.
22836                                 LightSrc    uint8
22837
22838                                 GndContent   bool
22839                                 Collides     bool
22840                                 Pointable    bool
22841                                 Diggable     bool
22842                                 Climbable    bool
22843                                 Replaceable  bool
22844                                 OnRightClick bool
22845
22846                                 DmgPerSec int32
22847
22848                                 LiquidType   LiquidType
22849                                 FlowingAlt   string
22850                                 SrcAlt       string
22851                                 Viscosity    uint8 // 0-7
22852                                 LiqRenewable bool
22853                                 FlowRange    uint8
22854                                 DrownDmg     uint8
22855                                 Floodable    bool
22856
22857                                 DrawBox, ColBox, SelBox NodeBox
22858
22859                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22860
22861                                 LegacyFaceDir bool
22862                                 LegacyMounted bool
22863
22864                                 DigPredict string
22865
22866                                 MaxLvl uint8
22867
22868                                 AlphaUse
22869
22870                                 MoveResistance uint8
22871
22872                                 LiquidMovePhysics bool
22873                         }))(obj)).DugSnd).deserialize(r)
22874                 }); err != nil {
22875                         if err == io.EOF {
22876                                 chk(io.EOF)
22877                         }
22878                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
22879                 }
22880                 {
22881                         p := &(*(*(struct {
22882                                 Param0 Content
22883
22884                                 Name   string
22885                                 Groups []Group
22886
22887                                 P1Type   Param1Type
22888                                 P2Type   Param2Type
22889                                 DrawType DrawType
22890
22891                                 Mesh  string
22892                                 Scale float32
22893                                 //mt:const uint8(6)
22894                                 Tiles        [6]TileDef
22895                                 OverlayTiles [6]TileDef
22896                                 //mt:const uint8(6)
22897                                 SpecialTiles [6]TileDef
22898
22899                                 Color   color.NRGBA
22900                                 Palette Texture
22901
22902                                 Waving       WaveType
22903                                 ConnectSides uint8
22904                                 ConnectTo    []Content
22905                                 InsideTint   color.NRGBA
22906                                 Level        uint8 // Must be < 128.
22907
22908                                 Translucent bool // Sunlight is scattered and becomes normal light.
22909                                 Transparent bool // Sunlight isn't scattered.
22910                                 LightSrc    uint8
22911
22912                                 GndContent   bool
22913                                 Collides     bool
22914                                 Pointable    bool
22915                                 Diggable     bool
22916                                 Climbable    bool
22917                                 Replaceable  bool
22918                                 OnRightClick bool
22919
22920                                 DmgPerSec int32
22921
22922                                 LiquidType   LiquidType
22923                                 FlowingAlt   string
22924                                 SrcAlt       string
22925                                 Viscosity    uint8 // 0-7
22926                                 LiqRenewable bool
22927                                 FlowRange    uint8
22928                                 DrownDmg     uint8
22929                                 Floodable    bool
22930
22931                                 DrawBox, ColBox, SelBox NodeBox
22932
22933                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
22934
22935                                 LegacyFaceDir bool
22936                                 LegacyMounted bool
22937
22938                                 DigPredict string
22939
22940                                 MaxLvl uint8
22941
22942                                 AlphaUse
22943
22944                                 MoveResistance uint8
22945
22946                                 LiquidMovePhysics bool
22947                         }))(obj)).LegacyFaceDir
22948                         switch n := read8(r); n {
22949                         case 0:
22950                                 *p = false
22951                         case 1:
22952                                 *p = true
22953                         default:
22954                                 chk(fmt.Errorf("invalid bool: %d", n))
22955                         }
22956                 }
22957                 {
22958                         p := &(*(*(struct {
22959                                 Param0 Content
22960
22961                                 Name   string
22962                                 Groups []Group
22963
22964                                 P1Type   Param1Type
22965                                 P2Type   Param2Type
22966                                 DrawType DrawType
22967
22968                                 Mesh  string
22969                                 Scale float32
22970                                 //mt:const uint8(6)
22971                                 Tiles        [6]TileDef
22972                                 OverlayTiles [6]TileDef
22973                                 //mt:const uint8(6)
22974                                 SpecialTiles [6]TileDef
22975
22976                                 Color   color.NRGBA
22977                                 Palette Texture
22978
22979                                 Waving       WaveType
22980                                 ConnectSides uint8
22981                                 ConnectTo    []Content
22982                                 InsideTint   color.NRGBA
22983                                 Level        uint8 // Must be < 128.
22984
22985                                 Translucent bool // Sunlight is scattered and becomes normal light.
22986                                 Transparent bool // Sunlight isn't scattered.
22987                                 LightSrc    uint8
22988
22989                                 GndContent   bool
22990                                 Collides     bool
22991                                 Pointable    bool
22992                                 Diggable     bool
22993                                 Climbable    bool
22994                                 Replaceable  bool
22995                                 OnRightClick bool
22996
22997                                 DmgPerSec int32
22998
22999                                 LiquidType   LiquidType
23000                                 FlowingAlt   string
23001                                 SrcAlt       string
23002                                 Viscosity    uint8 // 0-7
23003                                 LiqRenewable bool
23004                                 FlowRange    uint8
23005                                 DrownDmg     uint8
23006                                 Floodable    bool
23007
23008                                 DrawBox, ColBox, SelBox NodeBox
23009
23010                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23011
23012                                 LegacyFaceDir bool
23013                                 LegacyMounted bool
23014
23015                                 DigPredict string
23016
23017                                 MaxLvl uint8
23018
23019                                 AlphaUse
23020
23021                                 MoveResistance uint8
23022
23023                                 LiquidMovePhysics bool
23024                         }))(obj)).LegacyMounted
23025                         switch n := read8(r); n {
23026                         case 0:
23027                                 *p = false
23028                         case 1:
23029                                 *p = true
23030                         default:
23031                                 chk(fmt.Errorf("invalid bool: %d", n))
23032                         }
23033                 }
23034                 var local267 []uint8
23035                 var local268 uint16
23036                 {
23037                         p := &local268
23038                         *p = read16(r)
23039                 }
23040                 (local267) = make([]uint8, local268)
23041                 {
23042                         _, err := io.ReadFull(r, (local267)[:])
23043                         chk(err)
23044                 }
23045                 ((*(*(struct {
23046                         Param0 Content
23047
23048                         Name   string
23049                         Groups []Group
23050
23051                         P1Type   Param1Type
23052                         P2Type   Param2Type
23053                         DrawType DrawType
23054
23055                         Mesh  string
23056                         Scale float32
23057                         //mt:const uint8(6)
23058                         Tiles        [6]TileDef
23059                         OverlayTiles [6]TileDef
23060                         //mt:const uint8(6)
23061                         SpecialTiles [6]TileDef
23062
23063                         Color   color.NRGBA
23064                         Palette Texture
23065
23066                         Waving       WaveType
23067                         ConnectSides uint8
23068                         ConnectTo    []Content
23069                         InsideTint   color.NRGBA
23070                         Level        uint8 // Must be < 128.
23071
23072                         Translucent bool // Sunlight is scattered and becomes normal light.
23073                         Transparent bool // Sunlight isn't scattered.
23074                         LightSrc    uint8
23075
23076                         GndContent   bool
23077                         Collides     bool
23078                         Pointable    bool
23079                         Diggable     bool
23080                         Climbable    bool
23081                         Replaceable  bool
23082                         OnRightClick bool
23083
23084                         DmgPerSec int32
23085
23086                         LiquidType   LiquidType
23087                         FlowingAlt   string
23088                         SrcAlt       string
23089                         Viscosity    uint8 // 0-7
23090                         LiqRenewable bool
23091                         FlowRange    uint8
23092                         DrownDmg     uint8
23093                         Floodable    bool
23094
23095                         DrawBox, ColBox, SelBox NodeBox
23096
23097                         FootstepSnd, DiggingSnd, DugSnd SoundDef
23098
23099                         LegacyFaceDir bool
23100                         LegacyMounted bool
23101
23102                         DigPredict string
23103
23104                         MaxLvl uint8
23105
23106                         AlphaUse
23107
23108                         MoveResistance uint8
23109
23110                         LiquidMovePhysics bool
23111                 }))(obj)).DigPredict) = string(local267)
23112                 {
23113                         p := &(*(*(struct {
23114                                 Param0 Content
23115
23116                                 Name   string
23117                                 Groups []Group
23118
23119                                 P1Type   Param1Type
23120                                 P2Type   Param2Type
23121                                 DrawType DrawType
23122
23123                                 Mesh  string
23124                                 Scale float32
23125                                 //mt:const uint8(6)
23126                                 Tiles        [6]TileDef
23127                                 OverlayTiles [6]TileDef
23128                                 //mt:const uint8(6)
23129                                 SpecialTiles [6]TileDef
23130
23131                                 Color   color.NRGBA
23132                                 Palette Texture
23133
23134                                 Waving       WaveType
23135                                 ConnectSides uint8
23136                                 ConnectTo    []Content
23137                                 InsideTint   color.NRGBA
23138                                 Level        uint8 // Must be < 128.
23139
23140                                 Translucent bool // Sunlight is scattered and becomes normal light.
23141                                 Transparent bool // Sunlight isn't scattered.
23142                                 LightSrc    uint8
23143
23144                                 GndContent   bool
23145                                 Collides     bool
23146                                 Pointable    bool
23147                                 Diggable     bool
23148                                 Climbable    bool
23149                                 Replaceable  bool
23150                                 OnRightClick bool
23151
23152                                 DmgPerSec int32
23153
23154                                 LiquidType   LiquidType
23155                                 FlowingAlt   string
23156                                 SrcAlt       string
23157                                 Viscosity    uint8 // 0-7
23158                                 LiqRenewable bool
23159                                 FlowRange    uint8
23160                                 DrownDmg     uint8
23161                                 Floodable    bool
23162
23163                                 DrawBox, ColBox, SelBox NodeBox
23164
23165                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23166
23167                                 LegacyFaceDir bool
23168                                 LegacyMounted bool
23169
23170                                 DigPredict string
23171
23172                                 MaxLvl uint8
23173
23174                                 AlphaUse
23175
23176                                 MoveResistance uint8
23177
23178                                 LiquidMovePhysics bool
23179                         }))(obj)).MaxLvl
23180                         *p = read8(r)
23181                 }
23182                 if err := pcall(func() {
23183                         ((*(*(struct {
23184                                 Param0 Content
23185
23186                                 Name   string
23187                                 Groups []Group
23188
23189                                 P1Type   Param1Type
23190                                 P2Type   Param2Type
23191                                 DrawType DrawType
23192
23193                                 Mesh  string
23194                                 Scale float32
23195                                 //mt:const uint8(6)
23196                                 Tiles        [6]TileDef
23197                                 OverlayTiles [6]TileDef
23198                                 //mt:const uint8(6)
23199                                 SpecialTiles [6]TileDef
23200
23201                                 Color   color.NRGBA
23202                                 Palette Texture
23203
23204                                 Waving       WaveType
23205                                 ConnectSides uint8
23206                                 ConnectTo    []Content
23207                                 InsideTint   color.NRGBA
23208                                 Level        uint8 // Must be < 128.
23209
23210                                 Translucent bool // Sunlight is scattered and becomes normal light.
23211                                 Transparent bool // Sunlight isn't scattered.
23212                                 LightSrc    uint8
23213
23214                                 GndContent   bool
23215                                 Collides     bool
23216                                 Pointable    bool
23217                                 Diggable     bool
23218                                 Climbable    bool
23219                                 Replaceable  bool
23220                                 OnRightClick bool
23221
23222                                 DmgPerSec int32
23223
23224                                 LiquidType   LiquidType
23225                                 FlowingAlt   string
23226                                 SrcAlt       string
23227                                 Viscosity    uint8 // 0-7
23228                                 LiqRenewable bool
23229                                 FlowRange    uint8
23230                                 DrownDmg     uint8
23231                                 Floodable    bool
23232
23233                                 DrawBox, ColBox, SelBox NodeBox
23234
23235                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23236
23237                                 LegacyFaceDir bool
23238                                 LegacyMounted bool
23239
23240                                 DigPredict string
23241
23242                                 MaxLvl uint8
23243
23244                                 AlphaUse
23245
23246                                 MoveResistance uint8
23247
23248                                 LiquidMovePhysics bool
23249                         }))(obj)).AlphaUse).deserialize(r)
23250                 }); err != nil {
23251                         if err == io.EOF {
23252                                 chk(io.EOF)
23253                         }
23254                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlphaUse", err))
23255                 }
23256                 {
23257                         p := &(*(*(struct {
23258                                 Param0 Content
23259
23260                                 Name   string
23261                                 Groups []Group
23262
23263                                 P1Type   Param1Type
23264                                 P2Type   Param2Type
23265                                 DrawType DrawType
23266
23267                                 Mesh  string
23268                                 Scale float32
23269                                 //mt:const uint8(6)
23270                                 Tiles        [6]TileDef
23271                                 OverlayTiles [6]TileDef
23272                                 //mt:const uint8(6)
23273                                 SpecialTiles [6]TileDef
23274
23275                                 Color   color.NRGBA
23276                                 Palette Texture
23277
23278                                 Waving       WaveType
23279                                 ConnectSides uint8
23280                                 ConnectTo    []Content
23281                                 InsideTint   color.NRGBA
23282                                 Level        uint8 // Must be < 128.
23283
23284                                 Translucent bool // Sunlight is scattered and becomes normal light.
23285                                 Transparent bool // Sunlight isn't scattered.
23286                                 LightSrc    uint8
23287
23288                                 GndContent   bool
23289                                 Collides     bool
23290                                 Pointable    bool
23291                                 Diggable     bool
23292                                 Climbable    bool
23293                                 Replaceable  bool
23294                                 OnRightClick bool
23295
23296                                 DmgPerSec int32
23297
23298                                 LiquidType   LiquidType
23299                                 FlowingAlt   string
23300                                 SrcAlt       string
23301                                 Viscosity    uint8 // 0-7
23302                                 LiqRenewable bool
23303                                 FlowRange    uint8
23304                                 DrownDmg     uint8
23305                                 Floodable    bool
23306
23307                                 DrawBox, ColBox, SelBox NodeBox
23308
23309                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23310
23311                                 LegacyFaceDir bool
23312                                 LegacyMounted bool
23313
23314                                 DigPredict string
23315
23316                                 MaxLvl uint8
23317
23318                                 AlphaUse
23319
23320                                 MoveResistance uint8
23321
23322                                 LiquidMovePhysics bool
23323                         }))(obj)).MoveResistance
23324                         *p = read8(r)
23325                 }
23326                 {
23327                         p := &(*(*(struct {
23328                                 Param0 Content
23329
23330                                 Name   string
23331                                 Groups []Group
23332
23333                                 P1Type   Param1Type
23334                                 P2Type   Param2Type
23335                                 DrawType DrawType
23336
23337                                 Mesh  string
23338                                 Scale float32
23339                                 //mt:const uint8(6)
23340                                 Tiles        [6]TileDef
23341                                 OverlayTiles [6]TileDef
23342                                 //mt:const uint8(6)
23343                                 SpecialTiles [6]TileDef
23344
23345                                 Color   color.NRGBA
23346                                 Palette Texture
23347
23348                                 Waving       WaveType
23349                                 ConnectSides uint8
23350                                 ConnectTo    []Content
23351                                 InsideTint   color.NRGBA
23352                                 Level        uint8 // Must be < 128.
23353
23354                                 Translucent bool // Sunlight is scattered and becomes normal light.
23355                                 Transparent bool // Sunlight isn't scattered.
23356                                 LightSrc    uint8
23357
23358                                 GndContent   bool
23359                                 Collides     bool
23360                                 Pointable    bool
23361                                 Diggable     bool
23362                                 Climbable    bool
23363                                 Replaceable  bool
23364                                 OnRightClick bool
23365
23366                                 DmgPerSec int32
23367
23368                                 LiquidType   LiquidType
23369                                 FlowingAlt   string
23370                                 SrcAlt       string
23371                                 Viscosity    uint8 // 0-7
23372                                 LiqRenewable bool
23373                                 FlowRange    uint8
23374                                 DrownDmg     uint8
23375                                 Floodable    bool
23376
23377                                 DrawBox, ColBox, SelBox NodeBox
23378
23379                                 FootstepSnd, DiggingSnd, DugSnd SoundDef
23380
23381                                 LegacyFaceDir bool
23382                                 LegacyMounted bool
23383
23384                                 DigPredict string
23385
23386                                 MaxLvl uint8
23387
23388                                 AlphaUse
23389
23390                                 MoveResistance uint8
23391
23392                                 LiquidMovePhysics bool
23393                         }))(obj)).LiquidMovePhysics
23394                         switch n := read8(r); n {
23395                         case 0:
23396                                 *p = false
23397                         case 1:
23398                                 *p = true
23399                         default:
23400                                 chk(fmt.Errorf("invalid bool: %d", n))
23401                         }
23402                 }
23403                 if r.N > 0 {
23404                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
23405                 }
23406         }
23407 }
23408
23409 func (obj *PointedNode) serialize(w io.Writer) {
23410         for local269 := range (*(*(struct {
23411                 Under, Above [3]int16
23412         }))(obj)).Under {
23413                 {
23414                         x := ((*(*(struct {
23415                                 Under, Above [3]int16
23416                         }))(obj)).Under)[local269]
23417                         write16(w, uint16(x))
23418                 }
23419         }
23420         for local270 := range (*(*(struct {
23421                 Under, Above [3]int16
23422         }))(obj)).Above {
23423                 {
23424                         x := ((*(*(struct {
23425                                 Under, Above [3]int16
23426                         }))(obj)).Above)[local270]
23427                         write16(w, uint16(x))
23428                 }
23429         }
23430 }
23431
23432 func (obj *PointedNode) deserialize(r io.Reader) {
23433         for local271 := range (*(*(struct {
23434                 Under, Above [3]int16
23435         }))(obj)).Under {
23436                 {
23437                         p := &((*(*(struct {
23438                                 Under, Above [3]int16
23439                         }))(obj)).Under)[local271]
23440                         *p = int16(read16(r))
23441                 }
23442         }
23443         for local272 := range (*(*(struct {
23444                 Under, Above [3]int16
23445         }))(obj)).Above {
23446                 {
23447                         p := &((*(*(struct {
23448                                 Under, Above [3]int16
23449                         }))(obj)).Above)[local272]
23450                         *p = int16(read16(r))
23451                 }
23452         }
23453 }
23454
23455 func (obj *PointedAO) serialize(w io.Writer) {
23456         if err := pcall(func() {
23457                 ((*(*(struct {
23458                         ID AOID
23459                 }))(obj)).ID).serialize(w)
23460         }); err != nil {
23461                 if err == io.EOF {
23462                         chk(io.EOF)
23463                 }
23464                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23465         }
23466 }
23467
23468 func (obj *PointedAO) deserialize(r io.Reader) {
23469         if err := pcall(func() {
23470                 ((*(*(struct {
23471                         ID AOID
23472                 }))(obj)).ID).deserialize(r)
23473         }); err != nil {
23474                 if err == io.EOF {
23475                         chk(io.EOF)
23476                 }
23477                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
23478         }
23479 }
23480
23481 func (obj *CompressionModes) serialize(w io.Writer) {
23482         {
23483                 x := *(*(uint16))(obj)
23484                 write16(w, uint16(x))
23485         }
23486 }
23487
23488 func (obj *CompressionModes) deserialize(r io.Reader) {
23489         {
23490                 p := &*(*(uint16))(obj)
23491                 *p = read16(r)
23492         }
23493 }
23494
23495 func (obj *PlayerPos) serialize(w io.Writer) {
23496         for local273 := range (*(*(struct {
23497                 Pos100, Vel100   [3]int32
23498                 Pitch100, Yaw100 int32
23499                 Keys             Keys
23500                 FOV80            uint8
23501                 WantedRange      uint8 // in MapBlks.
23502         }))(obj)).Pos100 {
23503                 {
23504                         x := ((*(*(struct {
23505                                 Pos100, Vel100   [3]int32
23506                                 Pitch100, Yaw100 int32
23507                                 Keys             Keys
23508                                 FOV80            uint8
23509                                 WantedRange      uint8 // in MapBlks.
23510                         }))(obj)).Pos100)[local273]
23511                         write32(w, uint32(x))
23512                 }
23513         }
23514         for local274 := range (*(*(struct {
23515                 Pos100, Vel100   [3]int32
23516                 Pitch100, Yaw100 int32
23517                 Keys             Keys
23518                 FOV80            uint8
23519                 WantedRange      uint8 // in MapBlks.
23520         }))(obj)).Vel100 {
23521                 {
23522                         x := ((*(*(struct {
23523                                 Pos100, Vel100   [3]int32
23524                                 Pitch100, Yaw100 int32
23525                                 Keys             Keys
23526                                 FOV80            uint8
23527                                 WantedRange      uint8 // in MapBlks.
23528                         }))(obj)).Vel100)[local274]
23529                         write32(w, uint32(x))
23530                 }
23531         }
23532         {
23533                 x := (*(*(struct {
23534                         Pos100, Vel100   [3]int32
23535                         Pitch100, Yaw100 int32
23536                         Keys             Keys
23537                         FOV80            uint8
23538                         WantedRange      uint8 // in MapBlks.
23539                 }))(obj)).Pitch100
23540                 write32(w, uint32(x))
23541         }
23542         {
23543                 x := (*(*(struct {
23544                         Pos100, Vel100   [3]int32
23545                         Pitch100, Yaw100 int32
23546                         Keys             Keys
23547                         FOV80            uint8
23548                         WantedRange      uint8 // in MapBlks.
23549                 }))(obj)).Yaw100
23550                 write32(w, uint32(x))
23551         }
23552         if err := pcall(func() {
23553                 ((*(*(struct {
23554                         Pos100, Vel100   [3]int32
23555                         Pitch100, Yaw100 int32
23556                         Keys             Keys
23557                         FOV80            uint8
23558                         WantedRange      uint8 // in MapBlks.
23559                 }))(obj)).Keys).serialize(w)
23560         }); err != nil {
23561                 if err == io.EOF {
23562                         chk(io.EOF)
23563                 }
23564                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Keys", err))
23565         }
23566         {
23567                 x := (*(*(struct {
23568                         Pos100, Vel100   [3]int32
23569                         Pitch100, Yaw100 int32
23570                         Keys             Keys
23571                         FOV80            uint8
23572                         WantedRange      uint8 // in MapBlks.
23573                 }))(obj)).FOV80
23574                 write8(w, uint8(x))
23575         }
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)).WantedRange
23584                 write8(w, uint8(x))
23585         }
23586 }
23587
23588 func (obj *PlayerPos) deserialize(r io.Reader) {
23589         for local275 := range (*(*(struct {
23590                 Pos100, Vel100   [3]int32
23591                 Pitch100, Yaw100 int32
23592                 Keys             Keys
23593                 FOV80            uint8
23594                 WantedRange      uint8 // in MapBlks.
23595         }))(obj)).Pos100 {
23596                 {
23597                         p := &((*(*(struct {
23598                                 Pos100, Vel100   [3]int32
23599                                 Pitch100, Yaw100 int32
23600                                 Keys             Keys
23601                                 FOV80            uint8
23602                                 WantedRange      uint8 // in MapBlks.
23603                         }))(obj)).Pos100)[local275]
23604                         *p = int32(read32(r))
23605                 }
23606         }
23607         for local276 := range (*(*(struct {
23608                 Pos100, Vel100   [3]int32
23609                 Pitch100, Yaw100 int32
23610                 Keys             Keys
23611                 FOV80            uint8
23612                 WantedRange      uint8 // in MapBlks.
23613         }))(obj)).Vel100 {
23614                 {
23615                         p := &((*(*(struct {
23616                                 Pos100, Vel100   [3]int32
23617                                 Pitch100, Yaw100 int32
23618                                 Keys             Keys
23619                                 FOV80            uint8
23620                                 WantedRange      uint8 // in MapBlks.
23621                         }))(obj)).Vel100)[local276]
23622                         *p = int32(read32(r))
23623                 }
23624         }
23625         {
23626                 p := &(*(*(struct {
23627                         Pos100, Vel100   [3]int32
23628                         Pitch100, Yaw100 int32
23629                         Keys             Keys
23630                         FOV80            uint8
23631                         WantedRange      uint8 // in MapBlks.
23632                 }))(obj)).Pitch100
23633                 *p = int32(read32(r))
23634         }
23635         {
23636                 p := &(*(*(struct {
23637                         Pos100, Vel100   [3]int32
23638                         Pitch100, Yaw100 int32
23639                         Keys             Keys
23640                         FOV80            uint8
23641                         WantedRange      uint8 // in MapBlks.
23642                 }))(obj)).Yaw100
23643                 *p = int32(read32(r))
23644         }
23645         if err := pcall(func() {
23646                 ((*(*(struct {
23647                         Pos100, Vel100   [3]int32
23648                         Pitch100, Yaw100 int32
23649                         Keys             Keys
23650                         FOV80            uint8
23651                         WantedRange      uint8 // in MapBlks.
23652                 }))(obj)).Keys).deserialize(r)
23653         }); err != nil {
23654                 if err == io.EOF {
23655                         chk(io.EOF)
23656                 }
23657                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Keys", err))
23658         }
23659         {
23660                 p := &(*(*(struct {
23661                         Pos100, Vel100   [3]int32
23662                         Pitch100, Yaw100 int32
23663                         Keys             Keys
23664                         FOV80            uint8
23665                         WantedRange      uint8 // in MapBlks.
23666                 }))(obj)).FOV80
23667                 *p = read8(r)
23668         }
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)).WantedRange
23677                 *p = read8(r)
23678         }
23679 }
23680
23681 func (obj *Interaction) serialize(w io.Writer) {
23682         {
23683                 x := *(*(uint8))(obj)
23684                 write8(w, uint8(x))
23685         }
23686 }
23687
23688 func (obj *Interaction) deserialize(r io.Reader) {
23689         {
23690                 p := &*(*(uint8))(obj)
23691                 *p = read8(r)
23692         }
23693 }
23694
23695 func (obj *SoundID) serialize(w io.Writer) {
23696         {
23697                 x := *(*(int32))(obj)
23698                 write32(w, uint32(x))
23699         }
23700 }
23701
23702 func (obj *SoundID) deserialize(r io.Reader) {
23703         {
23704                 p := &*(*(int32))(obj)
23705                 *p = int32(read32(r))
23706         }
23707 }
23708
23709 func (obj *Field) serialize(w io.Writer) {
23710         if len(([]byte((*(*(struct {
23711                 Name string
23712
23713                 //mt:len32
23714                 Value string
23715         }))(obj)).Name))) > math.MaxUint16 {
23716                 chk(ErrTooLong)
23717         }
23718         {
23719                 x := uint16(len(([]byte((*(*(struct {
23720                         Name string
23721
23722                         //mt:len32
23723                         Value string
23724                 }))(obj)).Name))))
23725                 write16(w, uint16(x))
23726         }
23727         {
23728                 _, err := w.Write(([]byte((*(*(struct {
23729                         Name string
23730
23731                         //mt:len32
23732                         Value string
23733                 }))(obj)).Name))[:])
23734                 chk(err)
23735         }
23736         if len(([]byte((*(*(struct {
23737                 Name string
23738
23739                 //mt:len32
23740                 Value string
23741         }))(obj)).Value))) > math.MaxUint32 {
23742                 chk(ErrTooLong)
23743         }
23744         {
23745                 x := uint32(len(([]byte((*(*(struct {
23746                         Name string
23747
23748                         //mt:len32
23749                         Value string
23750                 }))(obj)).Value))))
23751                 write32(w, uint32(x))
23752         }
23753         {
23754                 _, err := w.Write(([]byte((*(*(struct {
23755                         Name string
23756
23757                         //mt:len32
23758                         Value string
23759                 }))(obj)).Value))[:])
23760                 chk(err)
23761         }
23762 }
23763
23764 func (obj *Field) deserialize(r io.Reader) {
23765         var local277 []uint8
23766         var local278 uint16
23767         {
23768                 p := &local278
23769                 *p = read16(r)
23770         }
23771         (local277) = make([]uint8, local278)
23772         {
23773                 _, err := io.ReadFull(r, (local277)[:])
23774                 chk(err)
23775         }
23776         ((*(*(struct {
23777                 Name string
23778
23779                 //mt:len32
23780                 Value string
23781         }))(obj)).Name) = string(local277)
23782         var local279 []uint8
23783         var local280 uint32
23784         {
23785                 p := &local280
23786                 *p = read32(r)
23787         }
23788         (local279) = make([]uint8, local280)
23789         {
23790                 _, err := io.ReadFull(r, (local279)[:])
23791                 chk(err)
23792         }
23793         ((*(*(struct {
23794                 Name string
23795
23796                 //mt:len32
23797                 Value string
23798         }))(obj)).Value) = string(local279)
23799 }
23800
23801 func (obj *AuthMethods) serialize(w io.Writer) {
23802         {
23803                 x := *(*(uint32))(obj)
23804                 write32(w, uint32(x))
23805         }
23806 }
23807
23808 func (obj *AuthMethods) deserialize(r io.Reader) {
23809         {
23810                 p := &*(*(uint32))(obj)
23811                 *p = read32(r)
23812         }
23813 }
23814
23815 func (obj *Pos) serialize(w io.Writer) {
23816         if err := pcall(func() {
23817                 (*(*(Vec))(obj)).serialize(w)
23818         }); err != nil {
23819                 if err == io.EOF {
23820                         chk(io.EOF)
23821                 }
23822                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
23823         }
23824 }
23825
23826 func (obj *Pos) deserialize(r io.Reader) {
23827         if err := pcall(func() {
23828                 (*(*(Vec))(obj)).deserialize(r)
23829         }); err != nil {
23830                 if err == io.EOF {
23831                         chk(io.EOF)
23832                 }
23833                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
23834         }
23835 }
23836
23837 func (obj *KickReason) serialize(w io.Writer) {
23838         {
23839                 x := *(*(uint8))(obj)
23840                 write8(w, uint8(x))
23841         }
23842 }
23843
23844 func (obj *KickReason) deserialize(r io.Reader) {
23845         {
23846                 p := &*(*(uint8))(obj)
23847                 *p = read8(r)
23848         }
23849 }
23850
23851 func (obj *MapBlk) serialize(w io.Writer) {
23852         if err := pcall(func() {
23853                 ((*(*(struct {
23854                         Flags   MapBlkFlags
23855                         LitFrom LitFromBlks
23856
23857                         //mt:zstd
23858                         Param0 [4096]Content
23859                         Param1 [4096]uint8
23860                         Param2 [4096]uint8
23861
23862                         NodeMetas map[uint16]*NodeMeta
23863                 }))(obj)).Flags).serialize(w)
23864         }); err != nil {
23865                 if err == io.EOF {
23866                         chk(io.EOF)
23867                 }
23868                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlkFlags", err))
23869         }
23870         if err := pcall(func() {
23871                 ((*(*(struct {
23872                         Flags   MapBlkFlags
23873                         LitFrom LitFromBlks
23874
23875                         //mt:zstd
23876                         Param0 [4096]Content
23877                         Param1 [4096]uint8
23878                         Param2 [4096]uint8
23879
23880                         NodeMetas map[uint16]*NodeMeta
23881                 }))(obj)).LitFrom).serialize(w)
23882         }); err != nil {
23883                 if err == io.EOF {
23884                         chk(io.EOF)
23885                 }
23886                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LitFromBlks", err))
23887         }
23888         {
23889                 local281 := uint8(2) // Size of param0 in bytes.
23890                 {
23891                         x := local281
23892                         write8(w, uint8(x))
23893                 }
23894         }
23895         {
23896                 local282 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
23897                 {
23898                         x := local282
23899                         write8(w, uint8(x))
23900                 }
23901         }
23902         {
23903                 w, err := zstd.NewWriter(w)
23904                 chk(err)
23905                 for local283 := range (*(*(struct {
23906                         Flags   MapBlkFlags
23907                         LitFrom LitFromBlks
23908
23909                         //mt:zstd
23910                         Param0 [4096]Content
23911                         Param1 [4096]uint8
23912                         Param2 [4096]uint8
23913
23914                         NodeMetas map[uint16]*NodeMeta
23915                 }))(obj)).Param0 {
23916                         if err := pcall(func() {
23917                                 (((*(*(struct {
23918                                         Flags   MapBlkFlags
23919                                         LitFrom LitFromBlks
23920
23921                                         //mt:zstd
23922                                         Param0 [4096]Content
23923                                         Param1 [4096]uint8
23924                                         Param2 [4096]uint8
23925
23926                                         NodeMetas map[uint16]*NodeMeta
23927                                 }))(obj)).Param0)[local283]).serialize(w)
23928                         }); err != nil {
23929                                 if err == io.EOF {
23930                                         chk(io.EOF)
23931                                 }
23932                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
23933                         }
23934                 }
23935                 {
23936                         _, err := w.Write(((*(*(struct {
23937                                 Flags   MapBlkFlags
23938                                 LitFrom LitFromBlks
23939
23940                                 //mt:zstd
23941                                 Param0 [4096]Content
23942                                 Param1 [4096]uint8
23943                                 Param2 [4096]uint8
23944
23945                                 NodeMetas map[uint16]*NodeMeta
23946                         }))(obj)).Param1)[:])
23947                         chk(err)
23948                 }
23949                 {
23950                         _, err := w.Write(((*(*(struct {
23951                                 Flags   MapBlkFlags
23952                                 LitFrom LitFromBlks
23953
23954                                 //mt:zstd
23955                                 Param0 [4096]Content
23956                                 Param1 [4096]uint8
23957                                 Param2 [4096]uint8
23958
23959                                 NodeMetas map[uint16]*NodeMeta
23960                         }))(obj)).Param2)[:])
23961                         chk(err)
23962                 }
23963                 chk(w.Close())
23964         }
23965         {
23966                 x := (*(*(struct {
23967                         Flags   MapBlkFlags
23968                         LitFrom LitFromBlks
23969
23970                         //mt:zstd
23971                         Param0 [4096]Content
23972                         Param1 [4096]uint8
23973                         Param2 [4096]uint8
23974
23975                         NodeMetas map[uint16]*NodeMeta
23976                 }))(obj)).NodeMetas
23977                 {
23978                         w := zlib.NewWriter(w)
23979                         if x == nil {
23980                                 write8(w, 0)
23981                         } else {
23982                                 write8(w, 2)
23983                                 // len(map[uint16]...) always < math.MaxUint16
23984                                 write16(w, uint16(len(x)))
23985                                 keys := make([]uint16, 0, len(x))
23986                                 for key := range x {
23987                                         keys = append(keys, key)
23988                                 }
23989                                 sort.Slice(keys, func(i, j int) bool {
23990                                         i2pos := func(i int) [3]int16 {
23991                                                 return Blkpos2Pos([3]int16{}, keys[i])
23992                                         }
23993                                         p, q := i2pos(i), i2pos(j)
23994                                         for i := range p {
23995                                                 switch {
23996                                                 case p[i] < q[i]:
23997                                                         return true
23998                                                 case p[i] > q[i]:
23999                                                         return false
24000                                                 }
24001                                         }
24002                                         return false
24003                                 })
24004                                 for _, key := range keys {
24005                                         write16(w, key)
24006                                         chk(serialize(w, x[key]))
24007                                 }
24008                         }
24009                         chk(w.Close())
24010                 }
24011         }
24012         {
24013                 local284 := uint8(2) // version
24014                 {
24015                         x := local284
24016                         write8(w, uint8(x))
24017                 }
24018         }
24019 }
24020
24021 func (obj *MapBlk) deserialize(r io.Reader) {
24022         if err := pcall(func() {
24023                 ((*(*(struct {
24024                         Flags   MapBlkFlags
24025                         LitFrom LitFromBlks
24026
24027                         //mt:zstd
24028                         Param0 [4096]Content
24029                         Param1 [4096]uint8
24030                         Param2 [4096]uint8
24031
24032                         NodeMetas map[uint16]*NodeMeta
24033                 }))(obj)).Flags).deserialize(r)
24034         }); err != nil {
24035                 if err == io.EOF {
24036                         chk(io.EOF)
24037                 }
24038                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.MapBlkFlags", err))
24039         }
24040         if err := pcall(func() {
24041                 ((*(*(struct {
24042                         Flags   MapBlkFlags
24043                         LitFrom LitFromBlks
24044
24045                         //mt:zstd
24046                         Param0 [4096]Content
24047                         Param1 [4096]uint8
24048                         Param2 [4096]uint8
24049
24050                         NodeMetas map[uint16]*NodeMeta
24051                 }))(obj)).LitFrom).deserialize(r)
24052         }); err != nil {
24053                 if err == io.EOF {
24054                         chk(io.EOF)
24055                 }
24056                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.LitFromBlks", err))
24057         }
24058         {
24059                 var local285 uint8
24060                 local286 := uint8(2) // Size of param0 in bytes.
24061                 {
24062                         p := &local285
24063                         *p = read8(r)
24064                 }
24065                 if local285 != local286 {
24066                         chk(fmt.Errorf("const %v: %v", "uint8(2)     // Size of param0 in bytes.", local285))
24067                 }
24068         }
24069         {
24070                 var local287 uint8
24071                 local288 := uint8(1 + 1) // Size of param1 and param2 combined, in bytes.
24072                 {
24073                         p := &local287
24074                         *p = read8(r)
24075                 }
24076                 if local287 != local288 {
24077                         chk(fmt.Errorf("const %v: %v", "uint8(1 + 1) // Size of param1 and param2 combined, in bytes.", local287))
24078                 }
24079         }
24080         {
24081                 r, err := zstd.NewReader(byteReader{r})
24082                 chk(err)
24083                 for local289 := range (*(*(struct {
24084                         Flags   MapBlkFlags
24085                         LitFrom LitFromBlks
24086
24087                         //mt:zstd
24088                         Param0 [4096]Content
24089                         Param1 [4096]uint8
24090                         Param2 [4096]uint8
24091
24092                         NodeMetas map[uint16]*NodeMeta
24093                 }))(obj)).Param0 {
24094                         if err := pcall(func() {
24095                                 (((*(*(struct {
24096                                         Flags   MapBlkFlags
24097                                         LitFrom LitFromBlks
24098
24099                                         //mt:zstd
24100                                         Param0 [4096]Content
24101                                         Param1 [4096]uint8
24102                                         Param2 [4096]uint8
24103
24104                                         NodeMetas map[uint16]*NodeMeta
24105                                 }))(obj)).Param0)[local289]).deserialize(r)
24106                         }); err != nil {
24107                                 if err == io.EOF {
24108                                         chk(io.EOF)
24109                                 }
24110                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24111                         }
24112                 }
24113                 {
24114                         _, err := io.ReadFull(r, ((*(*(struct {
24115                                 Flags   MapBlkFlags
24116                                 LitFrom LitFromBlks
24117
24118                                 //mt:zstd
24119                                 Param0 [4096]Content
24120                                 Param1 [4096]uint8
24121                                 Param2 [4096]uint8
24122
24123                                 NodeMetas map[uint16]*NodeMeta
24124                         }))(obj)).Param1)[:])
24125                         chk(err)
24126                 }
24127                 {
24128                         _, err := io.ReadFull(r, ((*(*(struct {
24129                                 Flags   MapBlkFlags
24130                                 LitFrom LitFromBlks
24131
24132                                 //mt:zstd
24133                                 Param0 [4096]Content
24134                                 Param1 [4096]uint8
24135                                 Param2 [4096]uint8
24136
24137                                 NodeMetas map[uint16]*NodeMeta
24138                         }))(obj)).Param2)[:])
24139                         chk(err)
24140                 }
24141                 r.Close()
24142         }
24143         {
24144                 p := &(*(*(struct {
24145                         Flags   MapBlkFlags
24146                         LitFrom LitFromBlks
24147
24148                         //mt:zstd
24149                         Param0 [4096]Content
24150                         Param1 [4096]uint8
24151                         Param2 [4096]uint8
24152
24153                         NodeMetas map[uint16]*NodeMeta
24154                 }))(obj)).NodeMetas
24155                 {
24156                         r, err := zlib.NewReader(byteReader{r})
24157                         chk(err)
24158                         switch ver := read8(r); ver {
24159                         case 0:
24160                                 *p = nil
24161                         case 2:
24162                                 n := read16(r)
24163                                 *p = make(map[uint16]*NodeMeta, n)
24164                                 for ; n > 0; n-- {
24165                                         pos := read16(r)
24166                                         nm := new(NodeMeta)
24167                                         chk(deserialize(r, nm))
24168                                         (*p)[pos] = nm
24169                                 }
24170                         default:
24171                                 chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
24172                         }
24173                         chk(r.Close())
24174                 }
24175         }
24176         {
24177                 var local290 uint8
24178                 local291 := uint8(2) // version
24179                 {
24180                         p := &local290
24181                         *p = read8(r)
24182                 }
24183                 if local290 != local291 {
24184                         chk(fmt.Errorf("const %v: %v", "uint8(2) // version", local290))
24185                 }
24186         }
24187 }
24188
24189 func (obj *Node) serialize(w io.Writer) {
24190         if err := pcall(func() {
24191                 ((*(*(struct {
24192                         Param0         Content
24193                         Param1, Param2 uint8
24194                 }))(obj)).Param0).serialize(w)
24195         }); err != nil {
24196                 if err == io.EOF {
24197                         chk(io.EOF)
24198                 }
24199                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24200         }
24201         {
24202                 x := (*(*(struct {
24203                         Param0         Content
24204                         Param1, Param2 uint8
24205                 }))(obj)).Param1
24206                 write8(w, uint8(x))
24207         }
24208         {
24209                 x := (*(*(struct {
24210                         Param0         Content
24211                         Param1, Param2 uint8
24212                 }))(obj)).Param2
24213                 write8(w, uint8(x))
24214         }
24215 }
24216
24217 func (obj *Node) deserialize(r io.Reader) {
24218         if err := pcall(func() {
24219                 ((*(*(struct {
24220                         Param0         Content
24221                         Param1, Param2 uint8
24222                 }))(obj)).Param0).deserialize(r)
24223         }); err != nil {
24224                 if err == io.EOF {
24225                         chk(io.EOF)
24226                 }
24227                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Content", err))
24228         }
24229         {
24230                 p := &(*(*(struct {
24231                         Param0         Content
24232                         Param1, Param2 uint8
24233                 }))(obj)).Param1
24234                 *p = read8(r)
24235         }
24236         {
24237                 p := &(*(*(struct {
24238                         Param0         Content
24239                         Param1, Param2 uint8
24240                 }))(obj)).Param2
24241                 *p = read8(r)
24242         }
24243 }
24244
24245 func (obj *CSMRestrictionFlags) serialize(w io.Writer) {
24246         {
24247                 x := *(*(uint64))(obj)
24248                 write64(w, uint64(x))
24249         }
24250 }
24251
24252 func (obj *CSMRestrictionFlags) deserialize(r io.Reader) {
24253         {
24254                 p := &*(*(uint64))(obj)
24255                 *p = read64(r)
24256         }
24257 }
24258
24259 func (obj *Vec) serialize(w io.Writer) {
24260         for local292 := range *(*([3]float32))(obj) {
24261                 {
24262                         x := (*(*([3]float32))(obj))[local292]
24263                         write32(w, math.Float32bits(x))
24264                 }
24265         }
24266 }
24267
24268 func (obj *Vec) deserialize(r io.Reader) {
24269         for local293 := range *(*([3]float32))(obj) {
24270                 {
24271                         p := &(*(*([3]float32))(obj))[local293]
24272                         *p = math.Float32frombits(read32(r))
24273                 }
24274         }
24275 }
24276
24277 func (obj *ChatMsgType) serialize(w io.Writer) {
24278         {
24279                 x := *(*(uint8))(obj)
24280                 write8(w, uint8(x))
24281         }
24282 }
24283
24284 func (obj *ChatMsgType) deserialize(r io.Reader) {
24285         {
24286                 p := &*(*(uint8))(obj)
24287                 *p = read8(r)
24288         }
24289 }
24290
24291 func (obj *AOID) serialize(w io.Writer) {
24292         {
24293                 x := *(*(uint16))(obj)
24294                 write16(w, uint16(x))
24295         }
24296 }
24297
24298 func (obj *AOID) deserialize(r io.Reader) {
24299         {
24300                 p := &*(*(uint16))(obj)
24301                 *p = read16(r)
24302         }
24303 }
24304
24305 func (obj *AOAdd) serialize(w io.Writer) {
24306         if err := pcall(func() {
24307                 ((*(*(struct {
24308                         ID AOID
24309                         //mt:const genericCAO
24310                         //mt:lenhdr 32
24311                         InitData AOInitData
24312                 }))(obj)).ID).serialize(w)
24313         }); err != nil {
24314                 if err == io.EOF {
24315                         chk(io.EOF)
24316                 }
24317                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24318         }
24319         {
24320                 local294 := genericCAO
24321                 if err := pcall(func() {
24322                         (local294).serialize(w)
24323                 }); err != nil {
24324                         if err == io.EOF {
24325                                 chk(io.EOF)
24326                         }
24327                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
24328                 }
24329         }
24330         {
24331                 ow := w
24332                 w := new(bytes.Buffer)
24333                 if err := pcall(func() {
24334                         ((*(*(struct {
24335                                 ID AOID
24336                                 //mt:const genericCAO
24337                                 //mt:lenhdr 32
24338                                 InitData AOInitData
24339                         }))(obj)).InitData).serialize(w)
24340                 }); err != nil {
24341                         if err == io.EOF {
24342                                 chk(io.EOF)
24343                         }
24344                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOInitData", err))
24345                 }
24346                 {
24347                         buf := w
24348                         w := ow
24349                         if len((buf.Bytes())) > math.MaxUint32 {
24350                                 chk(ErrTooLong)
24351                         }
24352                         {
24353                                 x := uint32(len((buf.Bytes())))
24354                                 write32(w, uint32(x))
24355                         }
24356                         {
24357                                 _, err := w.Write((buf.Bytes())[:])
24358                                 chk(err)
24359                         }
24360                 }
24361         }
24362 }
24363
24364 func (obj *AOAdd) deserialize(r io.Reader) {
24365         if err := pcall(func() {
24366                 ((*(*(struct {
24367                         ID AOID
24368                         //mt:const genericCAO
24369                         //mt:lenhdr 32
24370                         InitData AOInitData
24371                 }))(obj)).ID).deserialize(r)
24372         }); err != nil {
24373                 if err == io.EOF {
24374                         chk(io.EOF)
24375                 }
24376                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24377         }
24378         {
24379                 var local295 aoType
24380                 local296 := genericCAO
24381                 if err := pcall(func() {
24382                         (local295).deserialize(r)
24383                 }); err != nil {
24384                         if err == io.EOF {
24385                                 chk(io.EOF)
24386                         }
24387                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.aoType", err))
24388                 }
24389                 if local295 != local296 {
24390                         chk(fmt.Errorf("const %v: %v", "genericCAO", local295))
24391                 }
24392         }
24393         {
24394                 var n uint32
24395                 {
24396                         p := &n
24397                         *p = read32(r)
24398                 }
24399                 r := &io.LimitedReader{R: r, N: int64(n)}
24400                 if err := pcall(func() {
24401                         ((*(*(struct {
24402                                 ID AOID
24403                                 //mt:const genericCAO
24404                                 //mt:lenhdr 32
24405                                 InitData AOInitData
24406                         }))(obj)).InitData).deserialize(r)
24407                 }); err != nil {
24408                         if err == io.EOF {
24409                                 chk(io.EOF)
24410                         }
24411                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOInitData", err))
24412                 }
24413                 if r.N > 0 {
24414                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
24415                 }
24416         }
24417 }
24418
24419 func (obj *IDAOMsg) serialize(w io.Writer) {
24420         if err := pcall(func() {
24421                 ((*(*(struct {
24422                         ID AOID
24423                         //mt:lenhdr 16
24424                         Msg AOMsg
24425                 }))(obj)).ID).serialize(w)
24426         }); err != nil {
24427                 if err == io.EOF {
24428                         chk(io.EOF)
24429                 }
24430                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24431         }
24432         {
24433                 ow := w
24434                 w := new(bytes.Buffer)
24435                 {
24436                         x := (*(*(struct {
24437                                 ID AOID
24438                                 //mt:lenhdr 16
24439                                 Msg AOMsg
24440                         }))(obj)).Msg
24441                         writeAOMsg(w, x)
24442                 }
24443                 {
24444                         buf := w
24445                         w := ow
24446                         if len((buf.Bytes())) > math.MaxUint16 {
24447                                 chk(ErrTooLong)
24448                         }
24449                         {
24450                                 x := uint16(len((buf.Bytes())))
24451                                 write16(w, uint16(x))
24452                         }
24453                         {
24454                                 _, err := w.Write((buf.Bytes())[:])
24455                                 chk(err)
24456                         }
24457                 }
24458         }
24459 }
24460
24461 func (obj *IDAOMsg) deserialize(r io.Reader) {
24462         if err := pcall(func() {
24463                 ((*(*(struct {
24464                         ID AOID
24465                         //mt:lenhdr 16
24466                         Msg AOMsg
24467                 }))(obj)).ID).deserialize(r)
24468         }); err != nil {
24469                 if err == io.EOF {
24470                         chk(io.EOF)
24471                 }
24472                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
24473         }
24474         {
24475                 var n uint16
24476                 {
24477                         p := &n
24478                         *p = read16(r)
24479                 }
24480                 r := &io.LimitedReader{R: r, N: int64(n)}
24481                 {
24482                         p := &(*(*(struct {
24483                                 ID AOID
24484                                 //mt:lenhdr 16
24485                                 Msg AOMsg
24486                         }))(obj)).Msg
24487                         {
24488                                 var err error
24489                                 *p, err = readAOMsg(r)
24490                                 chk(err)
24491                         }
24492                 }
24493                 if r.N > 0 {
24494                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
24495                 }
24496         }
24497 }
24498
24499 func (obj *ItemDef) serialize(w io.Writer) {
24500         {
24501                 ow := w
24502                 w := new(bytes.Buffer)
24503                 {
24504                         local297 := uint8(6)
24505                         {
24506                                 x := local297
24507                                 write8(w, uint8(x))
24508                         }
24509                 }
24510                 if err := pcall(func() {
24511                         ((*(*(struct {
24512                                 Type ItemType
24513
24514                                 Name, Desc string
24515
24516                                 InvImg, WieldImg Texture
24517                                 WieldScale       [3]float32
24518
24519                                 StackMax uint16
24520
24521                                 Usable          bool
24522                                 CanPointLiquids bool
24523
24524                                 ToolCaps ToolCaps
24525
24526                                 Groups []Group
24527
24528                                 PlacePredict string
24529
24530                                 PlaceSnd, PlaceFailSnd SoundDef
24531
24532                                 PointRange float32
24533
24534                                 // Set index in Palette with "palette_index" item meta field,
24535                                 // this overrides Color.
24536                                 Palette Texture
24537                                 Color   color.NRGBA
24538
24539                                 // Texture overlays.
24540                                 InvOverlay, WieldOverlay Texture
24541
24542                                 ShortDesc string
24543
24544                                 PlaceParam2 uint8
24545                         }))(obj)).Type).serialize(w)
24546                 }); err != nil {
24547                         if err == io.EOF {
24548                                 chk(io.EOF)
24549                         }
24550                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemType", err))
24551                 }
24552                 if len(([]byte((*(*(struct {
24553                         Type ItemType
24554
24555                         Name, Desc string
24556
24557                         InvImg, WieldImg Texture
24558                         WieldScale       [3]float32
24559
24560                         StackMax uint16
24561
24562                         Usable          bool
24563                         CanPointLiquids bool
24564
24565                         ToolCaps ToolCaps
24566
24567                         Groups []Group
24568
24569                         PlacePredict string
24570
24571                         PlaceSnd, PlaceFailSnd SoundDef
24572
24573                         PointRange float32
24574
24575                         // Set index in Palette with "palette_index" item meta field,
24576                         // this overrides Color.
24577                         Palette Texture
24578                         Color   color.NRGBA
24579
24580                         // Texture overlays.
24581                         InvOverlay, WieldOverlay Texture
24582
24583                         ShortDesc string
24584
24585                         PlaceParam2 uint8
24586                 }))(obj)).Name))) > math.MaxUint16 {
24587                         chk(ErrTooLong)
24588                 }
24589                 {
24590                         x := uint16(len(([]byte((*(*(struct {
24591                                 Type ItemType
24592
24593                                 Name, Desc string
24594
24595                                 InvImg, WieldImg Texture
24596                                 WieldScale       [3]float32
24597
24598                                 StackMax uint16
24599
24600                                 Usable          bool
24601                                 CanPointLiquids bool
24602
24603                                 ToolCaps ToolCaps
24604
24605                                 Groups []Group
24606
24607                                 PlacePredict string
24608
24609                                 PlaceSnd, PlaceFailSnd SoundDef
24610
24611                                 PointRange float32
24612
24613                                 // Set index in Palette with "palette_index" item meta field,
24614                                 // this overrides Color.
24615                                 Palette Texture
24616                                 Color   color.NRGBA
24617
24618                                 // Texture overlays.
24619                                 InvOverlay, WieldOverlay Texture
24620
24621                                 ShortDesc string
24622
24623                                 PlaceParam2 uint8
24624                         }))(obj)).Name))))
24625                         write16(w, uint16(x))
24626                 }
24627                 {
24628                         _, err := w.Write(([]byte((*(*(struct {
24629                                 Type ItemType
24630
24631                                 Name, Desc string
24632
24633                                 InvImg, WieldImg Texture
24634                                 WieldScale       [3]float32
24635
24636                                 StackMax uint16
24637
24638                                 Usable          bool
24639                                 CanPointLiquids bool
24640
24641                                 ToolCaps ToolCaps
24642
24643                                 Groups []Group
24644
24645                                 PlacePredict string
24646
24647                                 PlaceSnd, PlaceFailSnd SoundDef
24648
24649                                 PointRange float32
24650
24651                                 // Set index in Palette with "palette_index" item meta field,
24652                                 // this overrides Color.
24653                                 Palette Texture
24654                                 Color   color.NRGBA
24655
24656                                 // Texture overlays.
24657                                 InvOverlay, WieldOverlay Texture
24658
24659                                 ShortDesc string
24660
24661                                 PlaceParam2 uint8
24662                         }))(obj)).Name))[:])
24663                         chk(err)
24664                 }
24665                 if len(([]byte((*(*(struct {
24666                         Type ItemType
24667
24668                         Name, Desc string
24669
24670                         InvImg, WieldImg Texture
24671                         WieldScale       [3]float32
24672
24673                         StackMax uint16
24674
24675                         Usable          bool
24676                         CanPointLiquids bool
24677
24678                         ToolCaps ToolCaps
24679
24680                         Groups []Group
24681
24682                         PlacePredict string
24683
24684                         PlaceSnd, PlaceFailSnd SoundDef
24685
24686                         PointRange float32
24687
24688                         // Set index in Palette with "palette_index" item meta field,
24689                         // this overrides Color.
24690                         Palette Texture
24691                         Color   color.NRGBA
24692
24693                         // Texture overlays.
24694                         InvOverlay, WieldOverlay Texture
24695
24696                         ShortDesc string
24697
24698                         PlaceParam2 uint8
24699                 }))(obj)).Desc))) > math.MaxUint16 {
24700                         chk(ErrTooLong)
24701                 }
24702                 {
24703                         x := uint16(len(([]byte((*(*(struct {
24704                                 Type ItemType
24705
24706                                 Name, Desc string
24707
24708                                 InvImg, WieldImg Texture
24709                                 WieldScale       [3]float32
24710
24711                                 StackMax uint16
24712
24713                                 Usable          bool
24714                                 CanPointLiquids bool
24715
24716                                 ToolCaps ToolCaps
24717
24718                                 Groups []Group
24719
24720                                 PlacePredict string
24721
24722                                 PlaceSnd, PlaceFailSnd SoundDef
24723
24724                                 PointRange float32
24725
24726                                 // Set index in Palette with "palette_index" item meta field,
24727                                 // this overrides Color.
24728                                 Palette Texture
24729                                 Color   color.NRGBA
24730
24731                                 // Texture overlays.
24732                                 InvOverlay, WieldOverlay Texture
24733
24734                                 ShortDesc string
24735
24736                                 PlaceParam2 uint8
24737                         }))(obj)).Desc))))
24738                         write16(w, uint16(x))
24739                 }
24740                 {
24741                         _, err := w.Write(([]byte((*(*(struct {
24742                                 Type ItemType
24743
24744                                 Name, Desc string
24745
24746                                 InvImg, WieldImg Texture
24747                                 WieldScale       [3]float32
24748
24749                                 StackMax uint16
24750
24751                                 Usable          bool
24752                                 CanPointLiquids bool
24753
24754                                 ToolCaps ToolCaps
24755
24756                                 Groups []Group
24757
24758                                 PlacePredict string
24759
24760                                 PlaceSnd, PlaceFailSnd SoundDef
24761
24762                                 PointRange float32
24763
24764                                 // Set index in Palette with "palette_index" item meta field,
24765                                 // this overrides Color.
24766                                 Palette Texture
24767                                 Color   color.NRGBA
24768
24769                                 // Texture overlays.
24770                                 InvOverlay, WieldOverlay Texture
24771
24772                                 ShortDesc string
24773
24774                                 PlaceParam2 uint8
24775                         }))(obj)).Desc))[:])
24776                         chk(err)
24777                 }
24778                 if err := pcall(func() {
24779                         ((*(*(struct {
24780                                 Type ItemType
24781
24782                                 Name, Desc string
24783
24784                                 InvImg, WieldImg Texture
24785                                 WieldScale       [3]float32
24786
24787                                 StackMax uint16
24788
24789                                 Usable          bool
24790                                 CanPointLiquids bool
24791
24792                                 ToolCaps ToolCaps
24793
24794                                 Groups []Group
24795
24796                                 PlacePredict string
24797
24798                                 PlaceSnd, PlaceFailSnd SoundDef
24799
24800                                 PointRange float32
24801
24802                                 // Set index in Palette with "palette_index" item meta field,
24803                                 // this overrides Color.
24804                                 Palette Texture
24805                                 Color   color.NRGBA
24806
24807                                 // Texture overlays.
24808                                 InvOverlay, WieldOverlay Texture
24809
24810                                 ShortDesc string
24811
24812                                 PlaceParam2 uint8
24813                         }))(obj)).InvImg).serialize(w)
24814                 }); err != nil {
24815                         if err == io.EOF {
24816                                 chk(io.EOF)
24817                         }
24818                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24819                 }
24820                 if err := pcall(func() {
24821                         ((*(*(struct {
24822                                 Type ItemType
24823
24824                                 Name, Desc string
24825
24826                                 InvImg, WieldImg Texture
24827                                 WieldScale       [3]float32
24828
24829                                 StackMax uint16
24830
24831                                 Usable          bool
24832                                 CanPointLiquids bool
24833
24834                                 ToolCaps ToolCaps
24835
24836                                 Groups []Group
24837
24838                                 PlacePredict string
24839
24840                                 PlaceSnd, PlaceFailSnd SoundDef
24841
24842                                 PointRange float32
24843
24844                                 // Set index in Palette with "palette_index" item meta field,
24845                                 // this overrides Color.
24846                                 Palette Texture
24847                                 Color   color.NRGBA
24848
24849                                 // Texture overlays.
24850                                 InvOverlay, WieldOverlay Texture
24851
24852                                 ShortDesc string
24853
24854                                 PlaceParam2 uint8
24855                         }))(obj)).WieldImg).serialize(w)
24856                 }); err != nil {
24857                         if err == io.EOF {
24858                                 chk(io.EOF)
24859                         }
24860                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
24861                 }
24862                 for local298 := range (*(*(struct {
24863                         Type ItemType
24864
24865                         Name, Desc string
24866
24867                         InvImg, WieldImg Texture
24868                         WieldScale       [3]float32
24869
24870                         StackMax uint16
24871
24872                         Usable          bool
24873                         CanPointLiquids bool
24874
24875                         ToolCaps ToolCaps
24876
24877                         Groups []Group
24878
24879                         PlacePredict string
24880
24881                         PlaceSnd, PlaceFailSnd SoundDef
24882
24883                         PointRange float32
24884
24885                         // Set index in Palette with "palette_index" item meta field,
24886                         // this overrides Color.
24887                         Palette Texture
24888                         Color   color.NRGBA
24889
24890                         // Texture overlays.
24891                         InvOverlay, WieldOverlay Texture
24892
24893                         ShortDesc string
24894
24895                         PlaceParam2 uint8
24896                 }))(obj)).WieldScale {
24897                         {
24898                                 x := ((*(*(struct {
24899                                         Type ItemType
24900
24901                                         Name, Desc string
24902
24903                                         InvImg, WieldImg Texture
24904                                         WieldScale       [3]float32
24905
24906                                         StackMax uint16
24907
24908                                         Usable          bool
24909                                         CanPointLiquids bool
24910
24911                                         ToolCaps ToolCaps
24912
24913                                         Groups []Group
24914
24915                                         PlacePredict string
24916
24917                                         PlaceSnd, PlaceFailSnd SoundDef
24918
24919                                         PointRange float32
24920
24921                                         // Set index in Palette with "palette_index" item meta field,
24922                                         // this overrides Color.
24923                                         Palette Texture
24924                                         Color   color.NRGBA
24925
24926                                         // Texture overlays.
24927                                         InvOverlay, WieldOverlay Texture
24928
24929                                         ShortDesc string
24930
24931                                         PlaceParam2 uint8
24932                                 }))(obj)).WieldScale)[local298]
24933                                 write32(w, math.Float32bits(x))
24934                         }
24935                 }
24936                 {
24937                         x := (*(*(struct {
24938                                 Type ItemType
24939
24940                                 Name, Desc string
24941
24942                                 InvImg, WieldImg Texture
24943                                 WieldScale       [3]float32
24944
24945                                 StackMax uint16
24946
24947                                 Usable          bool
24948                                 CanPointLiquids bool
24949
24950                                 ToolCaps ToolCaps
24951
24952                                 Groups []Group
24953
24954                                 PlacePredict string
24955
24956                                 PlaceSnd, PlaceFailSnd SoundDef
24957
24958                                 PointRange float32
24959
24960                                 // Set index in Palette with "palette_index" item meta field,
24961                                 // this overrides Color.
24962                                 Palette Texture
24963                                 Color   color.NRGBA
24964
24965                                 // Texture overlays.
24966                                 InvOverlay, WieldOverlay Texture
24967
24968                                 ShortDesc string
24969
24970                                 PlaceParam2 uint8
24971                         }))(obj)).StackMax
24972                         write16(w, uint16(x))
24973                 }
24974                 {
24975                         x := (*(*(struct {
24976                                 Type ItemType
24977
24978                                 Name, Desc string
24979
24980                                 InvImg, WieldImg Texture
24981                                 WieldScale       [3]float32
24982
24983                                 StackMax uint16
24984
24985                                 Usable          bool
24986                                 CanPointLiquids bool
24987
24988                                 ToolCaps ToolCaps
24989
24990                                 Groups []Group
24991
24992                                 PlacePredict string
24993
24994                                 PlaceSnd, PlaceFailSnd SoundDef
24995
24996                                 PointRange float32
24997
24998                                 // Set index in Palette with "palette_index" item meta field,
24999                                 // this overrides Color.
25000                                 Palette Texture
25001                                 Color   color.NRGBA
25002
25003                                 // Texture overlays.
25004                                 InvOverlay, WieldOverlay Texture
25005
25006                                 ShortDesc string
25007
25008                                 PlaceParam2 uint8
25009                         }))(obj)).Usable
25010                         if x {
25011                                 write8(w, 1)
25012                         } else {
25013                                 write8(w, 0)
25014                         }
25015                 }
25016                 {
25017                         x := (*(*(struct {
25018                                 Type ItemType
25019
25020                                 Name, Desc string
25021
25022                                 InvImg, WieldImg Texture
25023                                 WieldScale       [3]float32
25024
25025                                 StackMax uint16
25026
25027                                 Usable          bool
25028                                 CanPointLiquids bool
25029
25030                                 ToolCaps ToolCaps
25031
25032                                 Groups []Group
25033
25034                                 PlacePredict string
25035
25036                                 PlaceSnd, PlaceFailSnd SoundDef
25037
25038                                 PointRange float32
25039
25040                                 // Set index in Palette with "palette_index" item meta field,
25041                                 // this overrides Color.
25042                                 Palette Texture
25043                                 Color   color.NRGBA
25044
25045                                 // Texture overlays.
25046                                 InvOverlay, WieldOverlay Texture
25047
25048                                 ShortDesc string
25049
25050                                 PlaceParam2 uint8
25051                         }))(obj)).CanPointLiquids
25052                         if x {
25053                                 write8(w, 1)
25054                         } else {
25055                                 write8(w, 0)
25056                         }
25057                 }
25058                 if err := pcall(func() {
25059                         ((*(*(struct {
25060                                 Type ItemType
25061
25062                                 Name, Desc string
25063
25064                                 InvImg, WieldImg Texture
25065                                 WieldScale       [3]float32
25066
25067                                 StackMax uint16
25068
25069                                 Usable          bool
25070                                 CanPointLiquids bool
25071
25072                                 ToolCaps ToolCaps
25073
25074                                 Groups []Group
25075
25076                                 PlacePredict string
25077
25078                                 PlaceSnd, PlaceFailSnd SoundDef
25079
25080                                 PointRange float32
25081
25082                                 // Set index in Palette with "palette_index" item meta field,
25083                                 // this overrides Color.
25084                                 Palette Texture
25085                                 Color   color.NRGBA
25086
25087                                 // Texture overlays.
25088                                 InvOverlay, WieldOverlay Texture
25089
25090                                 ShortDesc string
25091
25092                                 PlaceParam2 uint8
25093                         }))(obj)).ToolCaps).serialize(w)
25094                 }); err != nil {
25095                         if err == io.EOF {
25096                                 chk(io.EOF)
25097                         }
25098                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolCaps", err))
25099                 }
25100                 if len(((*(*(struct {
25101                         Type ItemType
25102
25103                         Name, Desc string
25104
25105                         InvImg, WieldImg Texture
25106                         WieldScale       [3]float32
25107
25108                         StackMax uint16
25109
25110                         Usable          bool
25111                         CanPointLiquids bool
25112
25113                         ToolCaps ToolCaps
25114
25115                         Groups []Group
25116
25117                         PlacePredict string
25118
25119                         PlaceSnd, PlaceFailSnd SoundDef
25120
25121                         PointRange float32
25122
25123                         // Set index in Palette with "palette_index" item meta field,
25124                         // this overrides Color.
25125                         Palette Texture
25126                         Color   color.NRGBA
25127
25128                         // Texture overlays.
25129                         InvOverlay, WieldOverlay Texture
25130
25131                         ShortDesc string
25132
25133                         PlaceParam2 uint8
25134                 }))(obj)).Groups)) > math.MaxUint16 {
25135                         chk(ErrTooLong)
25136                 }
25137                 {
25138                         x := uint16(len(((*(*(struct {
25139                                 Type ItemType
25140
25141                                 Name, Desc string
25142
25143                                 InvImg, WieldImg Texture
25144                                 WieldScale       [3]float32
25145
25146                                 StackMax uint16
25147
25148                                 Usable          bool
25149                                 CanPointLiquids bool
25150
25151                                 ToolCaps ToolCaps
25152
25153                                 Groups []Group
25154
25155                                 PlacePredict string
25156
25157                                 PlaceSnd, PlaceFailSnd SoundDef
25158
25159                                 PointRange float32
25160
25161                                 // Set index in Palette with "palette_index" item meta field,
25162                                 // this overrides Color.
25163                                 Palette Texture
25164                                 Color   color.NRGBA
25165
25166                                 // Texture overlays.
25167                                 InvOverlay, WieldOverlay Texture
25168
25169                                 ShortDesc string
25170
25171                                 PlaceParam2 uint8
25172                         }))(obj)).Groups)))
25173                         write16(w, uint16(x))
25174                 }
25175                 for local299 := range (*(*(struct {
25176                         Type ItemType
25177
25178                         Name, Desc string
25179
25180                         InvImg, WieldImg Texture
25181                         WieldScale       [3]float32
25182
25183                         StackMax uint16
25184
25185                         Usable          bool
25186                         CanPointLiquids bool
25187
25188                         ToolCaps ToolCaps
25189
25190                         Groups []Group
25191
25192                         PlacePredict string
25193
25194                         PlaceSnd, PlaceFailSnd SoundDef
25195
25196                         PointRange float32
25197
25198                         // Set index in Palette with "palette_index" item meta field,
25199                         // this overrides Color.
25200                         Palette Texture
25201                         Color   color.NRGBA
25202
25203                         // Texture overlays.
25204                         InvOverlay, WieldOverlay Texture
25205
25206                         ShortDesc string
25207
25208                         PlaceParam2 uint8
25209                 }))(obj)).Groups {
25210                         if err := pcall(func() {
25211                                 (((*(*(struct {
25212                                         Type ItemType
25213
25214                                         Name, Desc string
25215
25216                                         InvImg, WieldImg Texture
25217                                         WieldScale       [3]float32
25218
25219                                         StackMax uint16
25220
25221                                         Usable          bool
25222                                         CanPointLiquids bool
25223
25224                                         ToolCaps ToolCaps
25225
25226                                         Groups []Group
25227
25228                                         PlacePredict string
25229
25230                                         PlaceSnd, PlaceFailSnd SoundDef
25231
25232                                         PointRange float32
25233
25234                                         // Set index in Palette with "palette_index" item meta field,
25235                                         // this overrides Color.
25236                                         Palette Texture
25237                                         Color   color.NRGBA
25238
25239                                         // Texture overlays.
25240                                         InvOverlay, WieldOverlay Texture
25241
25242                                         ShortDesc string
25243
25244                                         PlaceParam2 uint8
25245                                 }))(obj)).Groups)[local299]).serialize(w)
25246                         }); err != nil {
25247                                 if err == io.EOF {
25248                                         chk(io.EOF)
25249                                 }
25250                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
25251                         }
25252                 }
25253                 if len(([]byte((*(*(struct {
25254                         Type ItemType
25255
25256                         Name, Desc string
25257
25258                         InvImg, WieldImg Texture
25259                         WieldScale       [3]float32
25260
25261                         StackMax uint16
25262
25263                         Usable          bool
25264                         CanPointLiquids bool
25265
25266                         ToolCaps ToolCaps
25267
25268                         Groups []Group
25269
25270                         PlacePredict string
25271
25272                         PlaceSnd, PlaceFailSnd SoundDef
25273
25274                         PointRange float32
25275
25276                         // Set index in Palette with "palette_index" item meta field,
25277                         // this overrides Color.
25278                         Palette Texture
25279                         Color   color.NRGBA
25280
25281                         // Texture overlays.
25282                         InvOverlay, WieldOverlay Texture
25283
25284                         ShortDesc string
25285
25286                         PlaceParam2 uint8
25287                 }))(obj)).PlacePredict))) > math.MaxUint16 {
25288                         chk(ErrTooLong)
25289                 }
25290                 {
25291                         x := uint16(len(([]byte((*(*(struct {
25292                                 Type ItemType
25293
25294                                 Name, Desc string
25295
25296                                 InvImg, WieldImg Texture
25297                                 WieldScale       [3]float32
25298
25299                                 StackMax uint16
25300
25301                                 Usable          bool
25302                                 CanPointLiquids bool
25303
25304                                 ToolCaps ToolCaps
25305
25306                                 Groups []Group
25307
25308                                 PlacePredict string
25309
25310                                 PlaceSnd, PlaceFailSnd SoundDef
25311
25312                                 PointRange float32
25313
25314                                 // Set index in Palette with "palette_index" item meta field,
25315                                 // this overrides Color.
25316                                 Palette Texture
25317                                 Color   color.NRGBA
25318
25319                                 // Texture overlays.
25320                                 InvOverlay, WieldOverlay Texture
25321
25322                                 ShortDesc string
25323
25324                                 PlaceParam2 uint8
25325                         }))(obj)).PlacePredict))))
25326                         write16(w, uint16(x))
25327                 }
25328                 {
25329                         _, err := w.Write(([]byte((*(*(struct {
25330                                 Type ItemType
25331
25332                                 Name, Desc string
25333
25334                                 InvImg, WieldImg Texture
25335                                 WieldScale       [3]float32
25336
25337                                 StackMax uint16
25338
25339                                 Usable          bool
25340                                 CanPointLiquids bool
25341
25342                                 ToolCaps ToolCaps
25343
25344                                 Groups []Group
25345
25346                                 PlacePredict string
25347
25348                                 PlaceSnd, PlaceFailSnd SoundDef
25349
25350                                 PointRange float32
25351
25352                                 // Set index in Palette with "palette_index" item meta field,
25353                                 // this overrides Color.
25354                                 Palette Texture
25355                                 Color   color.NRGBA
25356
25357                                 // Texture overlays.
25358                                 InvOverlay, WieldOverlay Texture
25359
25360                                 ShortDesc string
25361
25362                                 PlaceParam2 uint8
25363                         }))(obj)).PlacePredict))[:])
25364                         chk(err)
25365                 }
25366                 if err := pcall(func() {
25367                         ((*(*(struct {
25368                                 Type ItemType
25369
25370                                 Name, Desc string
25371
25372                                 InvImg, WieldImg Texture
25373                                 WieldScale       [3]float32
25374
25375                                 StackMax uint16
25376
25377                                 Usable          bool
25378                                 CanPointLiquids bool
25379
25380                                 ToolCaps ToolCaps
25381
25382                                 Groups []Group
25383
25384                                 PlacePredict string
25385
25386                                 PlaceSnd, PlaceFailSnd SoundDef
25387
25388                                 PointRange float32
25389
25390                                 // Set index in Palette with "palette_index" item meta field,
25391                                 // this overrides Color.
25392                                 Palette Texture
25393                                 Color   color.NRGBA
25394
25395                                 // Texture overlays.
25396                                 InvOverlay, WieldOverlay Texture
25397
25398                                 ShortDesc string
25399
25400                                 PlaceParam2 uint8
25401                         }))(obj)).PlaceSnd).serialize(w)
25402                 }); err != nil {
25403                         if err == io.EOF {
25404                                 chk(io.EOF)
25405                         }
25406                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
25407                 }
25408                 if err := pcall(func() {
25409                         ((*(*(struct {
25410                                 Type ItemType
25411
25412                                 Name, Desc string
25413
25414                                 InvImg, WieldImg Texture
25415                                 WieldScale       [3]float32
25416
25417                                 StackMax uint16
25418
25419                                 Usable          bool
25420                                 CanPointLiquids bool
25421
25422                                 ToolCaps ToolCaps
25423
25424                                 Groups []Group
25425
25426                                 PlacePredict string
25427
25428                                 PlaceSnd, PlaceFailSnd SoundDef
25429
25430                                 PointRange float32
25431
25432                                 // Set index in Palette with "palette_index" item meta field,
25433                                 // this overrides Color.
25434                                 Palette Texture
25435                                 Color   color.NRGBA
25436
25437                                 // Texture overlays.
25438                                 InvOverlay, WieldOverlay Texture
25439
25440                                 ShortDesc string
25441
25442                                 PlaceParam2 uint8
25443                         }))(obj)).PlaceFailSnd).serialize(w)
25444                 }); err != nil {
25445                         if err == io.EOF {
25446                                 chk(io.EOF)
25447                         }
25448                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
25449                 }
25450                 {
25451                         x := (*(*(struct {
25452                                 Type ItemType
25453
25454                                 Name, Desc string
25455
25456                                 InvImg, WieldImg Texture
25457                                 WieldScale       [3]float32
25458
25459                                 StackMax uint16
25460
25461                                 Usable          bool
25462                                 CanPointLiquids bool
25463
25464                                 ToolCaps ToolCaps
25465
25466                                 Groups []Group
25467
25468                                 PlacePredict string
25469
25470                                 PlaceSnd, PlaceFailSnd SoundDef
25471
25472                                 PointRange float32
25473
25474                                 // Set index in Palette with "palette_index" item meta field,
25475                                 // this overrides Color.
25476                                 Palette Texture
25477                                 Color   color.NRGBA
25478
25479                                 // Texture overlays.
25480                                 InvOverlay, WieldOverlay Texture
25481
25482                                 ShortDesc string
25483
25484                                 PlaceParam2 uint8
25485                         }))(obj)).PointRange
25486                         write32(w, math.Float32bits(x))
25487                 }
25488                 if err := pcall(func() {
25489                         ((*(*(struct {
25490                                 Type ItemType
25491
25492                                 Name, Desc string
25493
25494                                 InvImg, WieldImg Texture
25495                                 WieldScale       [3]float32
25496
25497                                 StackMax uint16
25498
25499                                 Usable          bool
25500                                 CanPointLiquids bool
25501
25502                                 ToolCaps ToolCaps
25503
25504                                 Groups []Group
25505
25506                                 PlacePredict string
25507
25508                                 PlaceSnd, PlaceFailSnd SoundDef
25509
25510                                 PointRange float32
25511
25512                                 // Set index in Palette with "palette_index" item meta field,
25513                                 // this overrides Color.
25514                                 Palette Texture
25515                                 Color   color.NRGBA
25516
25517                                 // Texture overlays.
25518                                 InvOverlay, WieldOverlay Texture
25519
25520                                 ShortDesc string
25521
25522                                 PlaceParam2 uint8
25523                         }))(obj)).Palette).serialize(w)
25524                 }); err != nil {
25525                         if err == io.EOF {
25526                                 chk(io.EOF)
25527                         }
25528                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25529                 }
25530                 {
25531                         x := (*(*(struct {
25532                                 Type ItemType
25533
25534                                 Name, Desc string
25535
25536                                 InvImg, WieldImg Texture
25537                                 WieldScale       [3]float32
25538
25539                                 StackMax uint16
25540
25541                                 Usable          bool
25542                                 CanPointLiquids bool
25543
25544                                 ToolCaps ToolCaps
25545
25546                                 Groups []Group
25547
25548                                 PlacePredict string
25549
25550                                 PlaceSnd, PlaceFailSnd SoundDef
25551
25552                                 PointRange float32
25553
25554                                 // Set index in Palette with "palette_index" item meta field,
25555                                 // this overrides Color.
25556                                 Palette Texture
25557                                 Color   color.NRGBA
25558
25559                                 // Texture overlays.
25560                                 InvOverlay, WieldOverlay Texture
25561
25562                                 ShortDesc string
25563
25564                                 PlaceParam2 uint8
25565                         }))(obj)).Color
25566                         w.Write([]byte{x.A, x.R, x.G, x.B})
25567                 }
25568                 if err := pcall(func() {
25569                         ((*(*(struct {
25570                                 Type ItemType
25571
25572                                 Name, Desc string
25573
25574                                 InvImg, WieldImg Texture
25575                                 WieldScale       [3]float32
25576
25577                                 StackMax uint16
25578
25579                                 Usable          bool
25580                                 CanPointLiquids bool
25581
25582                                 ToolCaps ToolCaps
25583
25584                                 Groups []Group
25585
25586                                 PlacePredict string
25587
25588                                 PlaceSnd, PlaceFailSnd SoundDef
25589
25590                                 PointRange float32
25591
25592                                 // Set index in Palette with "palette_index" item meta field,
25593                                 // this overrides Color.
25594                                 Palette Texture
25595                                 Color   color.NRGBA
25596
25597                                 // Texture overlays.
25598                                 InvOverlay, WieldOverlay Texture
25599
25600                                 ShortDesc string
25601
25602                                 PlaceParam2 uint8
25603                         }))(obj)).InvOverlay).serialize(w)
25604                 }); err != nil {
25605                         if err == io.EOF {
25606                                 chk(io.EOF)
25607                         }
25608                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25609                 }
25610                 if err := pcall(func() {
25611                         ((*(*(struct {
25612                                 Type ItemType
25613
25614                                 Name, Desc string
25615
25616                                 InvImg, WieldImg Texture
25617                                 WieldScale       [3]float32
25618
25619                                 StackMax uint16
25620
25621                                 Usable          bool
25622                                 CanPointLiquids bool
25623
25624                                 ToolCaps ToolCaps
25625
25626                                 Groups []Group
25627
25628                                 PlacePredict string
25629
25630                                 PlaceSnd, PlaceFailSnd SoundDef
25631
25632                                 PointRange float32
25633
25634                                 // Set index in Palette with "palette_index" item meta field,
25635                                 // this overrides Color.
25636                                 Palette Texture
25637                                 Color   color.NRGBA
25638
25639                                 // Texture overlays.
25640                                 InvOverlay, WieldOverlay Texture
25641
25642                                 ShortDesc string
25643
25644                                 PlaceParam2 uint8
25645                         }))(obj)).WieldOverlay).serialize(w)
25646                 }); err != nil {
25647                         if err == io.EOF {
25648                                 chk(io.EOF)
25649                         }
25650                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
25651                 }
25652                 if len(([]byte((*(*(struct {
25653                         Type ItemType
25654
25655                         Name, Desc string
25656
25657                         InvImg, WieldImg Texture
25658                         WieldScale       [3]float32
25659
25660                         StackMax uint16
25661
25662                         Usable          bool
25663                         CanPointLiquids bool
25664
25665                         ToolCaps ToolCaps
25666
25667                         Groups []Group
25668
25669                         PlacePredict string
25670
25671                         PlaceSnd, PlaceFailSnd SoundDef
25672
25673                         PointRange float32
25674
25675                         // Set index in Palette with "palette_index" item meta field,
25676                         // this overrides Color.
25677                         Palette Texture
25678                         Color   color.NRGBA
25679
25680                         // Texture overlays.
25681                         InvOverlay, WieldOverlay Texture
25682
25683                         ShortDesc string
25684
25685                         PlaceParam2 uint8
25686                 }))(obj)).ShortDesc))) > math.MaxUint16 {
25687                         chk(ErrTooLong)
25688                 }
25689                 {
25690                         x := uint16(len(([]byte((*(*(struct {
25691                                 Type ItemType
25692
25693                                 Name, Desc string
25694
25695                                 InvImg, WieldImg Texture
25696                                 WieldScale       [3]float32
25697
25698                                 StackMax uint16
25699
25700                                 Usable          bool
25701                                 CanPointLiquids bool
25702
25703                                 ToolCaps ToolCaps
25704
25705                                 Groups []Group
25706
25707                                 PlacePredict string
25708
25709                                 PlaceSnd, PlaceFailSnd SoundDef
25710
25711                                 PointRange float32
25712
25713                                 // Set index in Palette with "palette_index" item meta field,
25714                                 // this overrides Color.
25715                                 Palette Texture
25716                                 Color   color.NRGBA
25717
25718                                 // Texture overlays.
25719                                 InvOverlay, WieldOverlay Texture
25720
25721                                 ShortDesc string
25722
25723                                 PlaceParam2 uint8
25724                         }))(obj)).ShortDesc))))
25725                         write16(w, uint16(x))
25726                 }
25727                 {
25728                         _, err := w.Write(([]byte((*(*(struct {
25729                                 Type ItemType
25730
25731                                 Name, Desc string
25732
25733                                 InvImg, WieldImg Texture
25734                                 WieldScale       [3]float32
25735
25736                                 StackMax uint16
25737
25738                                 Usable          bool
25739                                 CanPointLiquids bool
25740
25741                                 ToolCaps ToolCaps
25742
25743                                 Groups []Group
25744
25745                                 PlacePredict string
25746
25747                                 PlaceSnd, PlaceFailSnd SoundDef
25748
25749                                 PointRange float32
25750
25751                                 // Set index in Palette with "palette_index" item meta field,
25752                                 // this overrides Color.
25753                                 Palette Texture
25754                                 Color   color.NRGBA
25755
25756                                 // Texture overlays.
25757                                 InvOverlay, WieldOverlay Texture
25758
25759                                 ShortDesc string
25760
25761                                 PlaceParam2 uint8
25762                         }))(obj)).ShortDesc))[:])
25763                         chk(err)
25764                 }
25765                 {
25766                         x := (*(*(struct {
25767                                 Type ItemType
25768
25769                                 Name, Desc string
25770
25771                                 InvImg, WieldImg Texture
25772                                 WieldScale       [3]float32
25773
25774                                 StackMax uint16
25775
25776                                 Usable          bool
25777                                 CanPointLiquids bool
25778
25779                                 ToolCaps ToolCaps
25780
25781                                 Groups []Group
25782
25783                                 PlacePredict string
25784
25785                                 PlaceSnd, PlaceFailSnd SoundDef
25786
25787                                 PointRange float32
25788
25789                                 // Set index in Palette with "palette_index" item meta field,
25790                                 // this overrides Color.
25791                                 Palette Texture
25792                                 Color   color.NRGBA
25793
25794                                 // Texture overlays.
25795                                 InvOverlay, WieldOverlay Texture
25796
25797                                 ShortDesc string
25798
25799                                 PlaceParam2 uint8
25800                         }))(obj)).PlaceParam2
25801                         write8(w, uint8(x))
25802                 }
25803                 {
25804                         buf := w
25805                         w := ow
25806                         if len((buf.Bytes())) > math.MaxUint16 {
25807                                 chk(ErrTooLong)
25808                         }
25809                         {
25810                                 x := uint16(len((buf.Bytes())))
25811                                 write16(w, uint16(x))
25812                         }
25813                         {
25814                                 _, err := w.Write((buf.Bytes())[:])
25815                                 chk(err)
25816                         }
25817                 }
25818         }
25819 }
25820
25821 func (obj *ItemDef) deserialize(r io.Reader) {
25822         {
25823                 var n uint16
25824                 {
25825                         p := &n
25826                         *p = read16(r)
25827                 }
25828                 r := &io.LimitedReader{R: r, N: int64(n)}
25829                 {
25830                         var local300 uint8
25831                         local301 := uint8(6)
25832                         {
25833                                 p := &local300
25834                                 *p = read8(r)
25835                         }
25836                         if local300 != local301 {
25837                                 chk(fmt.Errorf("const %v: %v", "uint8(6)", local300))
25838                         }
25839                 }
25840                 if err := pcall(func() {
25841                         ((*(*(struct {
25842                                 Type ItemType
25843
25844                                 Name, Desc string
25845
25846                                 InvImg, WieldImg Texture
25847                                 WieldScale       [3]float32
25848
25849                                 StackMax uint16
25850
25851                                 Usable          bool
25852                                 CanPointLiquids bool
25853
25854                                 ToolCaps ToolCaps
25855
25856                                 Groups []Group
25857
25858                                 PlacePredict string
25859
25860                                 PlaceSnd, PlaceFailSnd SoundDef
25861
25862                                 PointRange float32
25863
25864                                 // Set index in Palette with "palette_index" item meta field,
25865                                 // this overrides Color.
25866                                 Palette Texture
25867                                 Color   color.NRGBA
25868
25869                                 // Texture overlays.
25870                                 InvOverlay, WieldOverlay Texture
25871
25872                                 ShortDesc string
25873
25874                                 PlaceParam2 uint8
25875                         }))(obj)).Type).deserialize(r)
25876                 }); err != nil {
25877                         if err == io.EOF {
25878                                 chk(io.EOF)
25879                         }
25880                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ItemType", err))
25881                 }
25882                 var local302 []uint8
25883                 var local303 uint16
25884                 {
25885                         p := &local303
25886                         *p = read16(r)
25887                 }
25888                 (local302) = make([]uint8, local303)
25889                 {
25890                         _, err := io.ReadFull(r, (local302)[:])
25891                         chk(err)
25892                 }
25893                 ((*(*(struct {
25894                         Type ItemType
25895
25896                         Name, Desc string
25897
25898                         InvImg, WieldImg Texture
25899                         WieldScale       [3]float32
25900
25901                         StackMax uint16
25902
25903                         Usable          bool
25904                         CanPointLiquids bool
25905
25906                         ToolCaps ToolCaps
25907
25908                         Groups []Group
25909
25910                         PlacePredict string
25911
25912                         PlaceSnd, PlaceFailSnd SoundDef
25913
25914                         PointRange float32
25915
25916                         // Set index in Palette with "palette_index" item meta field,
25917                         // this overrides Color.
25918                         Palette Texture
25919                         Color   color.NRGBA
25920
25921                         // Texture overlays.
25922                         InvOverlay, WieldOverlay Texture
25923
25924                         ShortDesc string
25925
25926                         PlaceParam2 uint8
25927                 }))(obj)).Name) = string(local302)
25928                 var local304 []uint8
25929                 var local305 uint16
25930                 {
25931                         p := &local305
25932                         *p = read16(r)
25933                 }
25934                 (local304) = make([]uint8, local305)
25935                 {
25936                         _, err := io.ReadFull(r, (local304)[:])
25937                         chk(err)
25938                 }
25939                 ((*(*(struct {
25940                         Type ItemType
25941
25942                         Name, Desc string
25943
25944                         InvImg, WieldImg Texture
25945                         WieldScale       [3]float32
25946
25947                         StackMax uint16
25948
25949                         Usable          bool
25950                         CanPointLiquids bool
25951
25952                         ToolCaps ToolCaps
25953
25954                         Groups []Group
25955
25956                         PlacePredict string
25957
25958                         PlaceSnd, PlaceFailSnd SoundDef
25959
25960                         PointRange float32
25961
25962                         // Set index in Palette with "palette_index" item meta field,
25963                         // this overrides Color.
25964                         Palette Texture
25965                         Color   color.NRGBA
25966
25967                         // Texture overlays.
25968                         InvOverlay, WieldOverlay Texture
25969
25970                         ShortDesc string
25971
25972                         PlaceParam2 uint8
25973                 }))(obj)).Desc) = string(local304)
25974                 if err := pcall(func() {
25975                         ((*(*(struct {
25976                                 Type ItemType
25977
25978                                 Name, Desc string
25979
25980                                 InvImg, WieldImg Texture
25981                                 WieldScale       [3]float32
25982
25983                                 StackMax uint16
25984
25985                                 Usable          bool
25986                                 CanPointLiquids bool
25987
25988                                 ToolCaps ToolCaps
25989
25990                                 Groups []Group
25991
25992                                 PlacePredict string
25993
25994                                 PlaceSnd, PlaceFailSnd SoundDef
25995
25996                                 PointRange float32
25997
25998                                 // Set index in Palette with "palette_index" item meta field,
25999                                 // this overrides Color.
26000                                 Palette Texture
26001                                 Color   color.NRGBA
26002
26003                                 // Texture overlays.
26004                                 InvOverlay, WieldOverlay Texture
26005
26006                                 ShortDesc string
26007
26008                                 PlaceParam2 uint8
26009                         }))(obj)).InvImg).deserialize(r)
26010                 }); err != nil {
26011                         if err == io.EOF {
26012                                 chk(io.EOF)
26013                         }
26014                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26015                 }
26016                 if err := pcall(func() {
26017                         ((*(*(struct {
26018                                 Type ItemType
26019
26020                                 Name, Desc string
26021
26022                                 InvImg, WieldImg Texture
26023                                 WieldScale       [3]float32
26024
26025                                 StackMax uint16
26026
26027                                 Usable          bool
26028                                 CanPointLiquids bool
26029
26030                                 ToolCaps ToolCaps
26031
26032                                 Groups []Group
26033
26034                                 PlacePredict string
26035
26036                                 PlaceSnd, PlaceFailSnd SoundDef
26037
26038                                 PointRange float32
26039
26040                                 // Set index in Palette with "palette_index" item meta field,
26041                                 // this overrides Color.
26042                                 Palette Texture
26043                                 Color   color.NRGBA
26044
26045                                 // Texture overlays.
26046                                 InvOverlay, WieldOverlay Texture
26047
26048                                 ShortDesc string
26049
26050                                 PlaceParam2 uint8
26051                         }))(obj)).WieldImg).deserialize(r)
26052                 }); err != nil {
26053                         if err == io.EOF {
26054                                 chk(io.EOF)
26055                         }
26056                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26057                 }
26058                 for local306 := range (*(*(struct {
26059                         Type ItemType
26060
26061                         Name, Desc string
26062
26063                         InvImg, WieldImg Texture
26064                         WieldScale       [3]float32
26065
26066                         StackMax uint16
26067
26068                         Usable          bool
26069                         CanPointLiquids bool
26070
26071                         ToolCaps ToolCaps
26072
26073                         Groups []Group
26074
26075                         PlacePredict string
26076
26077                         PlaceSnd, PlaceFailSnd SoundDef
26078
26079                         PointRange float32
26080
26081                         // Set index in Palette with "palette_index" item meta field,
26082                         // this overrides Color.
26083                         Palette Texture
26084                         Color   color.NRGBA
26085
26086                         // Texture overlays.
26087                         InvOverlay, WieldOverlay Texture
26088
26089                         ShortDesc string
26090
26091                         PlaceParam2 uint8
26092                 }))(obj)).WieldScale {
26093                         {
26094                                 p := &((*(*(struct {
26095                                         Type ItemType
26096
26097                                         Name, Desc string
26098
26099                                         InvImg, WieldImg Texture
26100                                         WieldScale       [3]float32
26101
26102                                         StackMax uint16
26103
26104                                         Usable          bool
26105                                         CanPointLiquids bool
26106
26107                                         ToolCaps ToolCaps
26108
26109                                         Groups []Group
26110
26111                                         PlacePredict string
26112
26113                                         PlaceSnd, PlaceFailSnd SoundDef
26114
26115                                         PointRange float32
26116
26117                                         // Set index in Palette with "palette_index" item meta field,
26118                                         // this overrides Color.
26119                                         Palette Texture
26120                                         Color   color.NRGBA
26121
26122                                         // Texture overlays.
26123                                         InvOverlay, WieldOverlay Texture
26124
26125                                         ShortDesc string
26126
26127                                         PlaceParam2 uint8
26128                                 }))(obj)).WieldScale)[local306]
26129                                 *p = math.Float32frombits(read32(r))
26130                         }
26131                 }
26132                 {
26133                         p := &(*(*(struct {
26134                                 Type ItemType
26135
26136                                 Name, Desc string
26137
26138                                 InvImg, WieldImg Texture
26139                                 WieldScale       [3]float32
26140
26141                                 StackMax uint16
26142
26143                                 Usable          bool
26144                                 CanPointLiquids bool
26145
26146                                 ToolCaps ToolCaps
26147
26148                                 Groups []Group
26149
26150                                 PlacePredict string
26151
26152                                 PlaceSnd, PlaceFailSnd SoundDef
26153
26154                                 PointRange float32
26155
26156                                 // Set index in Palette with "palette_index" item meta field,
26157                                 // this overrides Color.
26158                                 Palette Texture
26159                                 Color   color.NRGBA
26160
26161                                 // Texture overlays.
26162                                 InvOverlay, WieldOverlay Texture
26163
26164                                 ShortDesc string
26165
26166                                 PlaceParam2 uint8
26167                         }))(obj)).StackMax
26168                         *p = read16(r)
26169                 }
26170                 {
26171                         p := &(*(*(struct {
26172                                 Type ItemType
26173
26174                                 Name, Desc string
26175
26176                                 InvImg, WieldImg Texture
26177                                 WieldScale       [3]float32
26178
26179                                 StackMax uint16
26180
26181                                 Usable          bool
26182                                 CanPointLiquids bool
26183
26184                                 ToolCaps ToolCaps
26185
26186                                 Groups []Group
26187
26188                                 PlacePredict string
26189
26190                                 PlaceSnd, PlaceFailSnd SoundDef
26191
26192                                 PointRange float32
26193
26194                                 // Set index in Palette with "palette_index" item meta field,
26195                                 // this overrides Color.
26196                                 Palette Texture
26197                                 Color   color.NRGBA
26198
26199                                 // Texture overlays.
26200                                 InvOverlay, WieldOverlay Texture
26201
26202                                 ShortDesc string
26203
26204                                 PlaceParam2 uint8
26205                         }))(obj)).Usable
26206                         switch n := read8(r); n {
26207                         case 0:
26208                                 *p = false
26209                         case 1:
26210                                 *p = true
26211                         default:
26212                                 chk(fmt.Errorf("invalid bool: %d", n))
26213                         }
26214                 }
26215                 {
26216                         p := &(*(*(struct {
26217                                 Type ItemType
26218
26219                                 Name, Desc string
26220
26221                                 InvImg, WieldImg Texture
26222                                 WieldScale       [3]float32
26223
26224                                 StackMax uint16
26225
26226                                 Usable          bool
26227                                 CanPointLiquids bool
26228
26229                                 ToolCaps ToolCaps
26230
26231                                 Groups []Group
26232
26233                                 PlacePredict string
26234
26235                                 PlaceSnd, PlaceFailSnd SoundDef
26236
26237                                 PointRange float32
26238
26239                                 // Set index in Palette with "palette_index" item meta field,
26240                                 // this overrides Color.
26241                                 Palette Texture
26242                                 Color   color.NRGBA
26243
26244                                 // Texture overlays.
26245                                 InvOverlay, WieldOverlay Texture
26246
26247                                 ShortDesc string
26248
26249                                 PlaceParam2 uint8
26250                         }))(obj)).CanPointLiquids
26251                         switch n := read8(r); n {
26252                         case 0:
26253                                 *p = false
26254                         case 1:
26255                                 *p = true
26256                         default:
26257                                 chk(fmt.Errorf("invalid bool: %d", n))
26258                         }
26259                 }
26260                 if err := pcall(func() {
26261                         ((*(*(struct {
26262                                 Type ItemType
26263
26264                                 Name, Desc string
26265
26266                                 InvImg, WieldImg Texture
26267                                 WieldScale       [3]float32
26268
26269                                 StackMax uint16
26270
26271                                 Usable          bool
26272                                 CanPointLiquids bool
26273
26274                                 ToolCaps ToolCaps
26275
26276                                 Groups []Group
26277
26278                                 PlacePredict string
26279
26280                                 PlaceSnd, PlaceFailSnd SoundDef
26281
26282                                 PointRange float32
26283
26284                                 // Set index in Palette with "palette_index" item meta field,
26285                                 // this overrides Color.
26286                                 Palette Texture
26287                                 Color   color.NRGBA
26288
26289                                 // Texture overlays.
26290                                 InvOverlay, WieldOverlay Texture
26291
26292                                 ShortDesc string
26293
26294                                 PlaceParam2 uint8
26295                         }))(obj)).ToolCaps).deserialize(r)
26296                 }); err != nil {
26297                         if err == io.EOF {
26298                                 chk(io.EOF)
26299                         }
26300                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolCaps", err))
26301                 }
26302                 var local307 uint16
26303                 {
26304                         p := &local307
26305                         *p = read16(r)
26306                 }
26307                 ((*(*(struct {
26308                         Type ItemType
26309
26310                         Name, Desc string
26311
26312                         InvImg, WieldImg Texture
26313                         WieldScale       [3]float32
26314
26315                         StackMax uint16
26316
26317                         Usable          bool
26318                         CanPointLiquids bool
26319
26320                         ToolCaps ToolCaps
26321
26322                         Groups []Group
26323
26324                         PlacePredict string
26325
26326                         PlaceSnd, PlaceFailSnd SoundDef
26327
26328                         PointRange float32
26329
26330                         // Set index in Palette with "palette_index" item meta field,
26331                         // this overrides Color.
26332                         Palette Texture
26333                         Color   color.NRGBA
26334
26335                         // Texture overlays.
26336                         InvOverlay, WieldOverlay Texture
26337
26338                         ShortDesc string
26339
26340                         PlaceParam2 uint8
26341                 }))(obj)).Groups) = make([]Group, local307)
26342                 for local308 := range (*(*(struct {
26343                         Type ItemType
26344
26345                         Name, Desc string
26346
26347                         InvImg, WieldImg Texture
26348                         WieldScale       [3]float32
26349
26350                         StackMax uint16
26351
26352                         Usable          bool
26353                         CanPointLiquids bool
26354
26355                         ToolCaps ToolCaps
26356
26357                         Groups []Group
26358
26359                         PlacePredict string
26360
26361                         PlaceSnd, PlaceFailSnd SoundDef
26362
26363                         PointRange float32
26364
26365                         // Set index in Palette with "palette_index" item meta field,
26366                         // this overrides Color.
26367                         Palette Texture
26368                         Color   color.NRGBA
26369
26370                         // Texture overlays.
26371                         InvOverlay, WieldOverlay Texture
26372
26373                         ShortDesc string
26374
26375                         PlaceParam2 uint8
26376                 }))(obj)).Groups {
26377                         if err := pcall(func() {
26378                                 (((*(*(struct {
26379                                         Type ItemType
26380
26381                                         Name, Desc string
26382
26383                                         InvImg, WieldImg Texture
26384                                         WieldScale       [3]float32
26385
26386                                         StackMax uint16
26387
26388                                         Usable          bool
26389                                         CanPointLiquids bool
26390
26391                                         ToolCaps ToolCaps
26392
26393                                         Groups []Group
26394
26395                                         PlacePredict string
26396
26397                                         PlaceSnd, PlaceFailSnd SoundDef
26398
26399                                         PointRange float32
26400
26401                                         // Set index in Palette with "palette_index" item meta field,
26402                                         // this overrides Color.
26403                                         Palette Texture
26404                                         Color   color.NRGBA
26405
26406                                         // Texture overlays.
26407                                         InvOverlay, WieldOverlay Texture
26408
26409                                         ShortDesc string
26410
26411                                         PlaceParam2 uint8
26412                                 }))(obj)).Groups)[local308]).deserialize(r)
26413                         }); err != nil {
26414                                 if err == io.EOF {
26415                                         chk(io.EOF)
26416                                 }
26417                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
26418                         }
26419                 }
26420                 var local309 []uint8
26421                 var local310 uint16
26422                 {
26423                         p := &local310
26424                         *p = read16(r)
26425                 }
26426                 (local309) = make([]uint8, local310)
26427                 {
26428                         _, err := io.ReadFull(r, (local309)[:])
26429                         chk(err)
26430                 }
26431                 ((*(*(struct {
26432                         Type ItemType
26433
26434                         Name, Desc string
26435
26436                         InvImg, WieldImg Texture
26437                         WieldScale       [3]float32
26438
26439                         StackMax uint16
26440
26441                         Usable          bool
26442                         CanPointLiquids bool
26443
26444                         ToolCaps ToolCaps
26445
26446                         Groups []Group
26447
26448                         PlacePredict string
26449
26450                         PlaceSnd, PlaceFailSnd SoundDef
26451
26452                         PointRange float32
26453
26454                         // Set index in Palette with "palette_index" item meta field,
26455                         // this overrides Color.
26456                         Palette Texture
26457                         Color   color.NRGBA
26458
26459                         // Texture overlays.
26460                         InvOverlay, WieldOverlay Texture
26461
26462                         ShortDesc string
26463
26464                         PlaceParam2 uint8
26465                 }))(obj)).PlacePredict) = string(local309)
26466                 if err := pcall(func() {
26467                         ((*(*(struct {
26468                                 Type ItemType
26469
26470                                 Name, Desc string
26471
26472                                 InvImg, WieldImg Texture
26473                                 WieldScale       [3]float32
26474
26475                                 StackMax uint16
26476
26477                                 Usable          bool
26478                                 CanPointLiquids bool
26479
26480                                 ToolCaps ToolCaps
26481
26482                                 Groups []Group
26483
26484                                 PlacePredict string
26485
26486                                 PlaceSnd, PlaceFailSnd SoundDef
26487
26488                                 PointRange float32
26489
26490                                 // Set index in Palette with "palette_index" item meta field,
26491                                 // this overrides Color.
26492                                 Palette Texture
26493                                 Color   color.NRGBA
26494
26495                                 // Texture overlays.
26496                                 InvOverlay, WieldOverlay Texture
26497
26498                                 ShortDesc string
26499
26500                                 PlaceParam2 uint8
26501                         }))(obj)).PlaceSnd).deserialize(r)
26502                 }); err != nil {
26503                         if err == io.EOF {
26504                                 chk(io.EOF)
26505                         }
26506                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
26507                 }
26508                 if err := pcall(func() {
26509                         ((*(*(struct {
26510                                 Type ItemType
26511
26512                                 Name, Desc string
26513
26514                                 InvImg, WieldImg Texture
26515                                 WieldScale       [3]float32
26516
26517                                 StackMax uint16
26518
26519                                 Usable          bool
26520                                 CanPointLiquids bool
26521
26522                                 ToolCaps ToolCaps
26523
26524                                 Groups []Group
26525
26526                                 PlacePredict string
26527
26528                                 PlaceSnd, PlaceFailSnd SoundDef
26529
26530                                 PointRange float32
26531
26532                                 // Set index in Palette with "palette_index" item meta field,
26533                                 // this overrides Color.
26534                                 Palette Texture
26535                                 Color   color.NRGBA
26536
26537                                 // Texture overlays.
26538                                 InvOverlay, WieldOverlay Texture
26539
26540                                 ShortDesc string
26541
26542                                 PlaceParam2 uint8
26543                         }))(obj)).PlaceFailSnd).deserialize(r)
26544                 }); err != nil {
26545                         if err == io.EOF {
26546                                 chk(io.EOF)
26547                         }
26548                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.SoundDef", err))
26549                 }
26550                 {
26551                         p := &(*(*(struct {
26552                                 Type ItemType
26553
26554                                 Name, Desc string
26555
26556                                 InvImg, WieldImg Texture
26557                                 WieldScale       [3]float32
26558
26559                                 StackMax uint16
26560
26561                                 Usable          bool
26562                                 CanPointLiquids bool
26563
26564                                 ToolCaps ToolCaps
26565
26566                                 Groups []Group
26567
26568                                 PlacePredict string
26569
26570                                 PlaceSnd, PlaceFailSnd SoundDef
26571
26572                                 PointRange float32
26573
26574                                 // Set index in Palette with "palette_index" item meta field,
26575                                 // this overrides Color.
26576                                 Palette Texture
26577                                 Color   color.NRGBA
26578
26579                                 // Texture overlays.
26580                                 InvOverlay, WieldOverlay Texture
26581
26582                                 ShortDesc string
26583
26584                                 PlaceParam2 uint8
26585                         }))(obj)).PointRange
26586                         *p = math.Float32frombits(read32(r))
26587                 }
26588                 if err := pcall(func() {
26589                         ((*(*(struct {
26590                                 Type ItemType
26591
26592                                 Name, Desc string
26593
26594                                 InvImg, WieldImg Texture
26595                                 WieldScale       [3]float32
26596
26597                                 StackMax uint16
26598
26599                                 Usable          bool
26600                                 CanPointLiquids bool
26601
26602                                 ToolCaps ToolCaps
26603
26604                                 Groups []Group
26605
26606                                 PlacePredict string
26607
26608                                 PlaceSnd, PlaceFailSnd SoundDef
26609
26610                                 PointRange float32
26611
26612                                 // Set index in Palette with "palette_index" item meta field,
26613                                 // this overrides Color.
26614                                 Palette Texture
26615                                 Color   color.NRGBA
26616
26617                                 // Texture overlays.
26618                                 InvOverlay, WieldOverlay Texture
26619
26620                                 ShortDesc string
26621
26622                                 PlaceParam2 uint8
26623                         }))(obj)).Palette).deserialize(r)
26624                 }); err != nil {
26625                         if err == io.EOF {
26626                                 chk(io.EOF)
26627                         }
26628                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26629                 }
26630                 {
26631                         p := &(*(*(struct {
26632                                 Type ItemType
26633
26634                                 Name, Desc string
26635
26636                                 InvImg, WieldImg Texture
26637                                 WieldScale       [3]float32
26638
26639                                 StackMax uint16
26640
26641                                 Usable          bool
26642                                 CanPointLiquids bool
26643
26644                                 ToolCaps ToolCaps
26645
26646                                 Groups []Group
26647
26648                                 PlacePredict string
26649
26650                                 PlaceSnd, PlaceFailSnd SoundDef
26651
26652                                 PointRange float32
26653
26654                                 // Set index in Palette with "palette_index" item meta field,
26655                                 // this overrides Color.
26656                                 Palette Texture
26657                                 Color   color.NRGBA
26658
26659                                 // Texture overlays.
26660                                 InvOverlay, WieldOverlay Texture
26661
26662                                 ShortDesc string
26663
26664                                 PlaceParam2 uint8
26665                         }))(obj)).Color
26666                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
26667                 }
26668                 if err := pcall(func() {
26669                         ((*(*(struct {
26670                                 Type ItemType
26671
26672                                 Name, Desc string
26673
26674                                 InvImg, WieldImg Texture
26675                                 WieldScale       [3]float32
26676
26677                                 StackMax uint16
26678
26679                                 Usable          bool
26680                                 CanPointLiquids bool
26681
26682                                 ToolCaps ToolCaps
26683
26684                                 Groups []Group
26685
26686                                 PlacePredict string
26687
26688                                 PlaceSnd, PlaceFailSnd SoundDef
26689
26690                                 PointRange float32
26691
26692                                 // Set index in Palette with "palette_index" item meta field,
26693                                 // this overrides Color.
26694                                 Palette Texture
26695                                 Color   color.NRGBA
26696
26697                                 // Texture overlays.
26698                                 InvOverlay, WieldOverlay Texture
26699
26700                                 ShortDesc string
26701
26702                                 PlaceParam2 uint8
26703                         }))(obj)).InvOverlay).deserialize(r)
26704                 }); err != nil {
26705                         if err == io.EOF {
26706                                 chk(io.EOF)
26707                         }
26708                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26709                 }
26710                 if err := pcall(func() {
26711                         ((*(*(struct {
26712                                 Type ItemType
26713
26714                                 Name, Desc string
26715
26716                                 InvImg, WieldImg Texture
26717                                 WieldScale       [3]float32
26718
26719                                 StackMax uint16
26720
26721                                 Usable          bool
26722                                 CanPointLiquids bool
26723
26724                                 ToolCaps ToolCaps
26725
26726                                 Groups []Group
26727
26728                                 PlacePredict string
26729
26730                                 PlaceSnd, PlaceFailSnd SoundDef
26731
26732                                 PointRange float32
26733
26734                                 // Set index in Palette with "palette_index" item meta field,
26735                                 // this overrides Color.
26736                                 Palette Texture
26737                                 Color   color.NRGBA
26738
26739                                 // Texture overlays.
26740                                 InvOverlay, WieldOverlay Texture
26741
26742                                 ShortDesc string
26743
26744                                 PlaceParam2 uint8
26745                         }))(obj)).WieldOverlay).deserialize(r)
26746                 }); err != nil {
26747                         if err == io.EOF {
26748                                 chk(io.EOF)
26749                         }
26750                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
26751                 }
26752                 var local311 []uint8
26753                 var local312 uint16
26754                 {
26755                         p := &local312
26756                         *p = read16(r)
26757                 }
26758                 (local311) = make([]uint8, local312)
26759                 {
26760                         _, err := io.ReadFull(r, (local311)[:])
26761                         chk(err)
26762                 }
26763                 ((*(*(struct {
26764                         Type ItemType
26765
26766                         Name, Desc string
26767
26768                         InvImg, WieldImg Texture
26769                         WieldScale       [3]float32
26770
26771                         StackMax uint16
26772
26773                         Usable          bool
26774                         CanPointLiquids bool
26775
26776                         ToolCaps ToolCaps
26777
26778                         Groups []Group
26779
26780                         PlacePredict string
26781
26782                         PlaceSnd, PlaceFailSnd SoundDef
26783
26784                         PointRange float32
26785
26786                         // Set index in Palette with "palette_index" item meta field,
26787                         // this overrides Color.
26788                         Palette Texture
26789                         Color   color.NRGBA
26790
26791                         // Texture overlays.
26792                         InvOverlay, WieldOverlay Texture
26793
26794                         ShortDesc string
26795
26796                         PlaceParam2 uint8
26797                 }))(obj)).ShortDesc) = string(local311)
26798                 {
26799                         p := &(*(*(struct {
26800                                 Type ItemType
26801
26802                                 Name, Desc string
26803
26804                                 InvImg, WieldImg Texture
26805                                 WieldScale       [3]float32
26806
26807                                 StackMax uint16
26808
26809                                 Usable          bool
26810                                 CanPointLiquids bool
26811
26812                                 ToolCaps ToolCaps
26813
26814                                 Groups []Group
26815
26816                                 PlacePredict string
26817
26818                                 PlaceSnd, PlaceFailSnd SoundDef
26819
26820                                 PointRange float32
26821
26822                                 // Set index in Palette with "palette_index" item meta field,
26823                                 // this overrides Color.
26824                                 Palette Texture
26825                                 Color   color.NRGBA
26826
26827                                 // Texture overlays.
26828                                 InvOverlay, WieldOverlay Texture
26829
26830                                 ShortDesc string
26831
26832                                 PlaceParam2 uint8
26833                         }))(obj)).PlaceParam2
26834                         *p = read8(r)
26835                 }
26836                 if r.N > 0 {
26837                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
26838                 }
26839         }
26840 }
26841
26842 func (obj *SoundSrcType) serialize(w io.Writer) {
26843         {
26844                 x := *(*(uint8))(obj)
26845                 write8(w, uint8(x))
26846         }
26847 }
26848
26849 func (obj *SoundSrcType) deserialize(r io.Reader) {
26850         {
26851                 p := &*(*(uint8))(obj)
26852                 *p = read8(r)
26853         }
26854 }
26855
26856 func (obj *TileAnim) serialize(w io.Writer) {
26857         if err := pcall(func() {
26858                 ((*(*(struct {
26859                         Type AnimType
26860
26861                         //mt:if %s.Type == SpriteSheetAnim
26862                         AspectRatio [2]uint8
26863
26864                         //mt:if %s.Type == VerticalFrameAnim
26865                         NFrames [2]uint16
26866
26867                         //mt:if %s.Type != NoAnim
26868                         Duration float32 // in seconds
26869
26870                 }))(obj)).Type).serialize(w)
26871         }); err != nil {
26872                 if err == io.EOF {
26873                         chk(io.EOF)
26874                 }
26875                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AnimType", err))
26876         }
26877         if !((*(*(struct {
26878                 Type AnimType
26879
26880                 //mt:if %s.Type == SpriteSheetAnim
26881                 AspectRatio [2]uint8
26882
26883                 //mt:if %s.Type == VerticalFrameAnim
26884                 NFrames [2]uint16
26885
26886                 //mt:if %s.Type != NoAnim
26887                 Duration float32 // in seconds
26888
26889         }))(obj)).Type < maxAnim) {
26890                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
26891         }
26892         if (*(*(struct {
26893                 Type AnimType
26894
26895                 //mt:if %s.Type == SpriteSheetAnim
26896                 AspectRatio [2]uint8
26897
26898                 //mt:if %s.Type == VerticalFrameAnim
26899                 NFrames [2]uint16
26900
26901                 //mt:if %s.Type != NoAnim
26902                 Duration float32 // in seconds
26903
26904         }))(obj)).Type == SpriteSheetAnim {
26905                 {
26906                         _, err := w.Write(((*(*(struct {
26907                                 Type AnimType
26908
26909                                 //mt:if %s.Type == SpriteSheetAnim
26910                                 AspectRatio [2]uint8
26911
26912                                 //mt:if %s.Type == VerticalFrameAnim
26913                                 NFrames [2]uint16
26914
26915                                 //mt:if %s.Type != NoAnim
26916                                 Duration float32 // in seconds
26917
26918                         }))(obj)).AspectRatio)[:])
26919                         chk(err)
26920                 }
26921         }
26922         if (*(*(struct {
26923                 Type AnimType
26924
26925                 //mt:if %s.Type == SpriteSheetAnim
26926                 AspectRatio [2]uint8
26927
26928                 //mt:if %s.Type == VerticalFrameAnim
26929                 NFrames [2]uint16
26930
26931                 //mt:if %s.Type != NoAnim
26932                 Duration float32 // in seconds
26933
26934         }))(obj)).Type == VerticalFrameAnim {
26935                 for local313 := range (*(*(struct {
26936                         Type AnimType
26937
26938                         //mt:if %s.Type == SpriteSheetAnim
26939                         AspectRatio [2]uint8
26940
26941                         //mt:if %s.Type == VerticalFrameAnim
26942                         NFrames [2]uint16
26943
26944                         //mt:if %s.Type != NoAnim
26945                         Duration float32 // in seconds
26946
26947                 }))(obj)).NFrames {
26948                         {
26949                                 x := ((*(*(struct {
26950                                         Type AnimType
26951
26952                                         //mt:if %s.Type == SpriteSheetAnim
26953                                         AspectRatio [2]uint8
26954
26955                                         //mt:if %s.Type == VerticalFrameAnim
26956                                         NFrames [2]uint16
26957
26958                                         //mt:if %s.Type != NoAnim
26959                                         Duration float32 // in seconds
26960
26961                                 }))(obj)).NFrames)[local313]
26962                                 write16(w, uint16(x))
26963                         }
26964                 }
26965         }
26966         if (*(*(struct {
26967                 Type AnimType
26968
26969                 //mt:if %s.Type == SpriteSheetAnim
26970                 AspectRatio [2]uint8
26971
26972                 //mt:if %s.Type == VerticalFrameAnim
26973                 NFrames [2]uint16
26974
26975                 //mt:if %s.Type != NoAnim
26976                 Duration float32 // in seconds
26977
26978         }))(obj)).Type != NoAnim {
26979                 {
26980                         x := (*(*(struct {
26981                                 Type AnimType
26982
26983                                 //mt:if %s.Type == SpriteSheetAnim
26984                                 AspectRatio [2]uint8
26985
26986                                 //mt:if %s.Type == VerticalFrameAnim
26987                                 NFrames [2]uint16
26988
26989                                 //mt:if %s.Type != NoAnim
26990                                 Duration float32 // in seconds
26991
26992                         }))(obj)).Duration
26993                         write32(w, math.Float32bits(x))
26994                 }
26995         }
26996 }
26997
26998 func (obj *TileAnim) deserialize(r io.Reader) {
26999         if err := pcall(func() {
27000                 ((*(*(struct {
27001                         Type AnimType
27002
27003                         //mt:if %s.Type == SpriteSheetAnim
27004                         AspectRatio [2]uint8
27005
27006                         //mt:if %s.Type == VerticalFrameAnim
27007                         NFrames [2]uint16
27008
27009                         //mt:if %s.Type != NoAnim
27010                         Duration float32 // in seconds
27011
27012                 }))(obj)).Type).deserialize(r)
27013         }); err != nil {
27014                 if err == io.EOF {
27015                         chk(io.EOF)
27016                 }
27017                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AnimType", err))
27018         }
27019         if !((*(*(struct {
27020                 Type AnimType
27021
27022                 //mt:if %s.Type == SpriteSheetAnim
27023                 AspectRatio [2]uint8
27024
27025                 //mt:if %s.Type == VerticalFrameAnim
27026                 NFrames [2]uint16
27027
27028                 //mt:if %s.Type != NoAnim
27029                 Duration float32 // in seconds
27030
27031         }))(obj)).Type < maxAnim) {
27032                 chk(errors.New("assertion failed: %s.Type < maxAnim"))
27033         }
27034         if (*(*(struct {
27035                 Type AnimType
27036
27037                 //mt:if %s.Type == SpriteSheetAnim
27038                 AspectRatio [2]uint8
27039
27040                 //mt:if %s.Type == VerticalFrameAnim
27041                 NFrames [2]uint16
27042
27043                 //mt:if %s.Type != NoAnim
27044                 Duration float32 // in seconds
27045
27046         }))(obj)).Type == SpriteSheetAnim {
27047                 {
27048                         _, err := io.ReadFull(r, ((*(*(struct {
27049                                 Type AnimType
27050
27051                                 //mt:if %s.Type == SpriteSheetAnim
27052                                 AspectRatio [2]uint8
27053
27054                                 //mt:if %s.Type == VerticalFrameAnim
27055                                 NFrames [2]uint16
27056
27057                                 //mt:if %s.Type != NoAnim
27058                                 Duration float32 // in seconds
27059
27060                         }))(obj)).AspectRatio)[:])
27061                         chk(err)
27062                 }
27063         }
27064         if (*(*(struct {
27065                 Type AnimType
27066
27067                 //mt:if %s.Type == SpriteSheetAnim
27068                 AspectRatio [2]uint8
27069
27070                 //mt:if %s.Type == VerticalFrameAnim
27071                 NFrames [2]uint16
27072
27073                 //mt:if %s.Type != NoAnim
27074                 Duration float32 // in seconds
27075
27076         }))(obj)).Type == VerticalFrameAnim {
27077                 for local314 := range (*(*(struct {
27078                         Type AnimType
27079
27080                         //mt:if %s.Type == SpriteSheetAnim
27081                         AspectRatio [2]uint8
27082
27083                         //mt:if %s.Type == VerticalFrameAnim
27084                         NFrames [2]uint16
27085
27086                         //mt:if %s.Type != NoAnim
27087                         Duration float32 // in seconds
27088
27089                 }))(obj)).NFrames {
27090                         {
27091                                 p := &((*(*(struct {
27092                                         Type AnimType
27093
27094                                         //mt:if %s.Type == SpriteSheetAnim
27095                                         AspectRatio [2]uint8
27096
27097                                         //mt:if %s.Type == VerticalFrameAnim
27098                                         NFrames [2]uint16
27099
27100                                         //mt:if %s.Type != NoAnim
27101                                         Duration float32 // in seconds
27102
27103                                 }))(obj)).NFrames)[local314]
27104                                 *p = read16(r)
27105                         }
27106                 }
27107         }
27108         if (*(*(struct {
27109                 Type AnimType
27110
27111                 //mt:if %s.Type == SpriteSheetAnim
27112                 AspectRatio [2]uint8
27113
27114                 //mt:if %s.Type == VerticalFrameAnim
27115                 NFrames [2]uint16
27116
27117                 //mt:if %s.Type != NoAnim
27118                 Duration float32 // in seconds
27119
27120         }))(obj)).Type != NoAnim {
27121                 {
27122                         p := &(*(*(struct {
27123                                 Type AnimType
27124
27125                                 //mt:if %s.Type == SpriteSheetAnim
27126                                 AspectRatio [2]uint8
27127
27128                                 //mt:if %s.Type == VerticalFrameAnim
27129                                 NFrames [2]uint16
27130
27131                                 //mt:if %s.Type != NoAnim
27132                                 Duration float32 // in seconds
27133
27134                         }))(obj)).Duration
27135                         *p = math.Float32frombits(read32(r))
27136                 }
27137         }
27138 }
27139
27140 func (obj *Content) serialize(w io.Writer) {
27141         {
27142                 x := *(*(uint16))(obj)
27143                 write16(w, uint16(x))
27144         }
27145 }
27146
27147 func (obj *Content) deserialize(r io.Reader) {
27148         {
27149                 p := &*(*(uint16))(obj)
27150                 *p = read16(r)
27151         }
27152 }
27153
27154 func (obj *ParticleSpawnerID) serialize(w io.Writer) {
27155         {
27156                 x := *(*(uint32))(obj)
27157                 write32(w, uint32(x))
27158         }
27159 }
27160
27161 func (obj *ParticleSpawnerID) deserialize(r io.Reader) {
27162         {
27163                 p := &*(*(uint32))(obj)
27164                 *p = read32(r)
27165         }
27166 }
27167
27168 func (obj *HUDID) serialize(w io.Writer) {
27169         {
27170                 x := *(*(uint32))(obj)
27171                 write32(w, uint32(x))
27172         }
27173 }
27174
27175 func (obj *HUDID) deserialize(r io.Reader) {
27176         {
27177                 p := &*(*(uint32))(obj)
27178                 *p = read32(r)
27179         }
27180 }
27181
27182 func (obj *HUD) serialize(w io.Writer) {
27183         if err := pcall(func() {
27184                 ((*(*(struct {
27185                         Type HUDType
27186
27187                         Pos      [2]float32
27188                         Name     string
27189                         Scale    [2]float32
27190                         Text     string
27191                         Number   uint32
27192                         Item     uint32
27193                         Dir      uint32
27194                         Align    [2]float32
27195                         Offset   [2]float32
27196                         WorldPos Pos
27197                         Size     [2]int32
27198                         ZIndex   int16
27199                         Text2    string
27200                         Style    uint32
27201                 }))(obj)).Type).serialize(w)
27202         }); err != nil {
27203                 if err == io.EOF {
27204                         chk(io.EOF)
27205                 }
27206                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
27207         }
27208         for local315 := range (*(*(struct {
27209                 Type HUDType
27210
27211                 Pos      [2]float32
27212                 Name     string
27213                 Scale    [2]float32
27214                 Text     string
27215                 Number   uint32
27216                 Item     uint32
27217                 Dir      uint32
27218                 Align    [2]float32
27219                 Offset   [2]float32
27220                 WorldPos Pos
27221                 Size     [2]int32
27222                 ZIndex   int16
27223                 Text2    string
27224                 Style    uint32
27225         }))(obj)).Pos {
27226                 {
27227                         x := ((*(*(struct {
27228                                 Type HUDType
27229
27230                                 Pos      [2]float32
27231                                 Name     string
27232                                 Scale    [2]float32
27233                                 Text     string
27234                                 Number   uint32
27235                                 Item     uint32
27236                                 Dir      uint32
27237                                 Align    [2]float32
27238                                 Offset   [2]float32
27239                                 WorldPos Pos
27240                                 Size     [2]int32
27241                                 ZIndex   int16
27242                                 Text2    string
27243                                 Style    uint32
27244                         }))(obj)).Pos)[local315]
27245                         write32(w, math.Float32bits(x))
27246                 }
27247         }
27248         if len(([]byte((*(*(struct {
27249                 Type HUDType
27250
27251                 Pos      [2]float32
27252                 Name     string
27253                 Scale    [2]float32
27254                 Text     string
27255                 Number   uint32
27256                 Item     uint32
27257                 Dir      uint32
27258                 Align    [2]float32
27259                 Offset   [2]float32
27260                 WorldPos Pos
27261                 Size     [2]int32
27262                 ZIndex   int16
27263                 Text2    string
27264                 Style    uint32
27265         }))(obj)).Name))) > math.MaxUint16 {
27266                 chk(ErrTooLong)
27267         }
27268         {
27269                 x := uint16(len(([]byte((*(*(struct {
27270                         Type HUDType
27271
27272                         Pos      [2]float32
27273                         Name     string
27274                         Scale    [2]float32
27275                         Text     string
27276                         Number   uint32
27277                         Item     uint32
27278                         Dir      uint32
27279                         Align    [2]float32
27280                         Offset   [2]float32
27281                         WorldPos Pos
27282                         Size     [2]int32
27283                         ZIndex   int16
27284                         Text2    string
27285                         Style    uint32
27286                 }))(obj)).Name))))
27287                 write16(w, uint16(x))
27288         }
27289         {
27290                 _, err := w.Write(([]byte((*(*(struct {
27291                         Type HUDType
27292
27293                         Pos      [2]float32
27294                         Name     string
27295                         Scale    [2]float32
27296                         Text     string
27297                         Number   uint32
27298                         Item     uint32
27299                         Dir      uint32
27300                         Align    [2]float32
27301                         Offset   [2]float32
27302                         WorldPos Pos
27303                         Size     [2]int32
27304                         ZIndex   int16
27305                         Text2    string
27306                         Style    uint32
27307                 }))(obj)).Name))[:])
27308                 chk(err)
27309         }
27310         for local316 := range (*(*(struct {
27311                 Type HUDType
27312
27313                 Pos      [2]float32
27314                 Name     string
27315                 Scale    [2]float32
27316                 Text     string
27317                 Number   uint32
27318                 Item     uint32
27319                 Dir      uint32
27320                 Align    [2]float32
27321                 Offset   [2]float32
27322                 WorldPos Pos
27323                 Size     [2]int32
27324                 ZIndex   int16
27325                 Text2    string
27326                 Style    uint32
27327         }))(obj)).Scale {
27328                 {
27329                         x := ((*(*(struct {
27330                                 Type HUDType
27331
27332                                 Pos      [2]float32
27333                                 Name     string
27334                                 Scale    [2]float32
27335                                 Text     string
27336                                 Number   uint32
27337                                 Item     uint32
27338                                 Dir      uint32
27339                                 Align    [2]float32
27340                                 Offset   [2]float32
27341                                 WorldPos Pos
27342                                 Size     [2]int32
27343                                 ZIndex   int16
27344                                 Text2    string
27345                                 Style    uint32
27346                         }))(obj)).Scale)[local316]
27347                         write32(w, math.Float32bits(x))
27348                 }
27349         }
27350         if len(([]byte((*(*(struct {
27351                 Type HUDType
27352
27353                 Pos      [2]float32
27354                 Name     string
27355                 Scale    [2]float32
27356                 Text     string
27357                 Number   uint32
27358                 Item     uint32
27359                 Dir      uint32
27360                 Align    [2]float32
27361                 Offset   [2]float32
27362                 WorldPos Pos
27363                 Size     [2]int32
27364                 ZIndex   int16
27365                 Text2    string
27366                 Style    uint32
27367         }))(obj)).Text))) > math.MaxUint16 {
27368                 chk(ErrTooLong)
27369         }
27370         {
27371                 x := uint16(len(([]byte((*(*(struct {
27372                         Type HUDType
27373
27374                         Pos      [2]float32
27375                         Name     string
27376                         Scale    [2]float32
27377                         Text     string
27378                         Number   uint32
27379                         Item     uint32
27380                         Dir      uint32
27381                         Align    [2]float32
27382                         Offset   [2]float32
27383                         WorldPos Pos
27384                         Size     [2]int32
27385                         ZIndex   int16
27386                         Text2    string
27387                         Style    uint32
27388                 }))(obj)).Text))))
27389                 write16(w, uint16(x))
27390         }
27391         {
27392                 _, err := w.Write(([]byte((*(*(struct {
27393                         Type HUDType
27394
27395                         Pos      [2]float32
27396                         Name     string
27397                         Scale    [2]float32
27398                         Text     string
27399                         Number   uint32
27400                         Item     uint32
27401                         Dir      uint32
27402                         Align    [2]float32
27403                         Offset   [2]float32
27404                         WorldPos Pos
27405                         Size     [2]int32
27406                         ZIndex   int16
27407                         Text2    string
27408                         Style    uint32
27409                 }))(obj)).Text))[:])
27410                 chk(err)
27411         }
27412         {
27413                 x := (*(*(struct {
27414                         Type HUDType
27415
27416                         Pos      [2]float32
27417                         Name     string
27418                         Scale    [2]float32
27419                         Text     string
27420                         Number   uint32
27421                         Item     uint32
27422                         Dir      uint32
27423                         Align    [2]float32
27424                         Offset   [2]float32
27425                         WorldPos Pos
27426                         Size     [2]int32
27427                         ZIndex   int16
27428                         Text2    string
27429                         Style    uint32
27430                 }))(obj)).Number
27431                 write32(w, uint32(x))
27432         }
27433         {
27434                 x := (*(*(struct {
27435                         Type HUDType
27436
27437                         Pos      [2]float32
27438                         Name     string
27439                         Scale    [2]float32
27440                         Text     string
27441                         Number   uint32
27442                         Item     uint32
27443                         Dir      uint32
27444                         Align    [2]float32
27445                         Offset   [2]float32
27446                         WorldPos Pos
27447                         Size     [2]int32
27448                         ZIndex   int16
27449                         Text2    string
27450                         Style    uint32
27451                 }))(obj)).Item
27452                 write32(w, uint32(x))
27453         }
27454         {
27455                 x := (*(*(struct {
27456                         Type HUDType
27457
27458                         Pos      [2]float32
27459                         Name     string
27460                         Scale    [2]float32
27461                         Text     string
27462                         Number   uint32
27463                         Item     uint32
27464                         Dir      uint32
27465                         Align    [2]float32
27466                         Offset   [2]float32
27467                         WorldPos Pos
27468                         Size     [2]int32
27469                         ZIndex   int16
27470                         Text2    string
27471                         Style    uint32
27472                 }))(obj)).Dir
27473                 write32(w, uint32(x))
27474         }
27475         for local317 := range (*(*(struct {
27476                 Type HUDType
27477
27478                 Pos      [2]float32
27479                 Name     string
27480                 Scale    [2]float32
27481                 Text     string
27482                 Number   uint32
27483                 Item     uint32
27484                 Dir      uint32
27485                 Align    [2]float32
27486                 Offset   [2]float32
27487                 WorldPos Pos
27488                 Size     [2]int32
27489                 ZIndex   int16
27490                 Text2    string
27491                 Style    uint32
27492         }))(obj)).Align {
27493                 {
27494                         x := ((*(*(struct {
27495                                 Type HUDType
27496
27497                                 Pos      [2]float32
27498                                 Name     string
27499                                 Scale    [2]float32
27500                                 Text     string
27501                                 Number   uint32
27502                                 Item     uint32
27503                                 Dir      uint32
27504                                 Align    [2]float32
27505                                 Offset   [2]float32
27506                                 WorldPos Pos
27507                                 Size     [2]int32
27508                                 ZIndex   int16
27509                                 Text2    string
27510                                 Style    uint32
27511                         }))(obj)).Align)[local317]
27512                         write32(w, math.Float32bits(x))
27513                 }
27514         }
27515         for local318 := range (*(*(struct {
27516                 Type HUDType
27517
27518                 Pos      [2]float32
27519                 Name     string
27520                 Scale    [2]float32
27521                 Text     string
27522                 Number   uint32
27523                 Item     uint32
27524                 Dir      uint32
27525                 Align    [2]float32
27526                 Offset   [2]float32
27527                 WorldPos Pos
27528                 Size     [2]int32
27529                 ZIndex   int16
27530                 Text2    string
27531                 Style    uint32
27532         }))(obj)).Offset {
27533                 {
27534                         x := ((*(*(struct {
27535                                 Type HUDType
27536
27537                                 Pos      [2]float32
27538                                 Name     string
27539                                 Scale    [2]float32
27540                                 Text     string
27541                                 Number   uint32
27542                                 Item     uint32
27543                                 Dir      uint32
27544                                 Align    [2]float32
27545                                 Offset   [2]float32
27546                                 WorldPos Pos
27547                                 Size     [2]int32
27548                                 ZIndex   int16
27549                                 Text2    string
27550                                 Style    uint32
27551                         }))(obj)).Offset)[local318]
27552                         write32(w, math.Float32bits(x))
27553                 }
27554         }
27555         if err := pcall(func() {
27556                 ((*(*(struct {
27557                         Type HUDType
27558
27559                         Pos      [2]float32
27560                         Name     string
27561                         Scale    [2]float32
27562                         Text     string
27563                         Number   uint32
27564                         Item     uint32
27565                         Dir      uint32
27566                         Align    [2]float32
27567                         Offset   [2]float32
27568                         WorldPos Pos
27569                         Size     [2]int32
27570                         ZIndex   int16
27571                         Text2    string
27572                         Style    uint32
27573                 }))(obj)).WorldPos).serialize(w)
27574         }); err != nil {
27575                 if err == io.EOF {
27576                         chk(io.EOF)
27577                 }
27578                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
27579         }
27580         for local319 := range (*(*(struct {
27581                 Type HUDType
27582
27583                 Pos      [2]float32
27584                 Name     string
27585                 Scale    [2]float32
27586                 Text     string
27587                 Number   uint32
27588                 Item     uint32
27589                 Dir      uint32
27590                 Align    [2]float32
27591                 Offset   [2]float32
27592                 WorldPos Pos
27593                 Size     [2]int32
27594                 ZIndex   int16
27595                 Text2    string
27596                 Style    uint32
27597         }))(obj)).Size {
27598                 {
27599                         x := ((*(*(struct {
27600                                 Type HUDType
27601
27602                                 Pos      [2]float32
27603                                 Name     string
27604                                 Scale    [2]float32
27605                                 Text     string
27606                                 Number   uint32
27607                                 Item     uint32
27608                                 Dir      uint32
27609                                 Align    [2]float32
27610                                 Offset   [2]float32
27611                                 WorldPos Pos
27612                                 Size     [2]int32
27613                                 ZIndex   int16
27614                                 Text2    string
27615                                 Style    uint32
27616                         }))(obj)).Size)[local319]
27617                         write32(w, uint32(x))
27618                 }
27619         }
27620         {
27621                 x := (*(*(struct {
27622                         Type HUDType
27623
27624                         Pos      [2]float32
27625                         Name     string
27626                         Scale    [2]float32
27627                         Text     string
27628                         Number   uint32
27629                         Item     uint32
27630                         Dir      uint32
27631                         Align    [2]float32
27632                         Offset   [2]float32
27633                         WorldPos Pos
27634                         Size     [2]int32
27635                         ZIndex   int16
27636                         Text2    string
27637                         Style    uint32
27638                 }))(obj)).ZIndex
27639                 write16(w, uint16(x))
27640         }
27641         if len(([]byte((*(*(struct {
27642                 Type HUDType
27643
27644                 Pos      [2]float32
27645                 Name     string
27646                 Scale    [2]float32
27647                 Text     string
27648                 Number   uint32
27649                 Item     uint32
27650                 Dir      uint32
27651                 Align    [2]float32
27652                 Offset   [2]float32
27653                 WorldPos Pos
27654                 Size     [2]int32
27655                 ZIndex   int16
27656                 Text2    string
27657                 Style    uint32
27658         }))(obj)).Text2))) > math.MaxUint16 {
27659                 chk(ErrTooLong)
27660         }
27661         {
27662                 x := uint16(len(([]byte((*(*(struct {
27663                         Type HUDType
27664
27665                         Pos      [2]float32
27666                         Name     string
27667                         Scale    [2]float32
27668                         Text     string
27669                         Number   uint32
27670                         Item     uint32
27671                         Dir      uint32
27672                         Align    [2]float32
27673                         Offset   [2]float32
27674                         WorldPos Pos
27675                         Size     [2]int32
27676                         ZIndex   int16
27677                         Text2    string
27678                         Style    uint32
27679                 }))(obj)).Text2))))
27680                 write16(w, uint16(x))
27681         }
27682         {
27683                 _, err := w.Write(([]byte((*(*(struct {
27684                         Type HUDType
27685
27686                         Pos      [2]float32
27687                         Name     string
27688                         Scale    [2]float32
27689                         Text     string
27690                         Number   uint32
27691                         Item     uint32
27692                         Dir      uint32
27693                         Align    [2]float32
27694                         Offset   [2]float32
27695                         WorldPos Pos
27696                         Size     [2]int32
27697                         ZIndex   int16
27698                         Text2    string
27699                         Style    uint32
27700                 }))(obj)).Text2))[:])
27701                 chk(err)
27702         }
27703         {
27704                 x := (*(*(struct {
27705                         Type HUDType
27706
27707                         Pos      [2]float32
27708                         Name     string
27709                         Scale    [2]float32
27710                         Text     string
27711                         Number   uint32
27712                         Item     uint32
27713                         Dir      uint32
27714                         Align    [2]float32
27715                         Offset   [2]float32
27716                         WorldPos Pos
27717                         Size     [2]int32
27718                         ZIndex   int16
27719                         Text2    string
27720                         Style    uint32
27721                 }))(obj)).Style
27722                 write32(w, uint32(x))
27723         }
27724 }
27725
27726 func (obj *HUD) deserialize(r io.Reader) {
27727         if err := pcall(func() {
27728                 ((*(*(struct {
27729                         Type HUDType
27730
27731                         Pos      [2]float32
27732                         Name     string
27733                         Scale    [2]float32
27734                         Text     string
27735                         Number   uint32
27736                         Item     uint32
27737                         Dir      uint32
27738                         Align    [2]float32
27739                         Offset   [2]float32
27740                         WorldPos Pos
27741                         Size     [2]int32
27742                         ZIndex   int16
27743                         Text2    string
27744                         Style    uint32
27745                 }))(obj)).Type).deserialize(r)
27746         }); err != nil {
27747                 if err == io.EOF {
27748                         chk(io.EOF)
27749                 }
27750                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.HUDType", err))
27751         }
27752         for local320 := range (*(*(struct {
27753                 Type HUDType
27754
27755                 Pos      [2]float32
27756                 Name     string
27757                 Scale    [2]float32
27758                 Text     string
27759                 Number   uint32
27760                 Item     uint32
27761                 Dir      uint32
27762                 Align    [2]float32
27763                 Offset   [2]float32
27764                 WorldPos Pos
27765                 Size     [2]int32
27766                 ZIndex   int16
27767                 Text2    string
27768                 Style    uint32
27769         }))(obj)).Pos {
27770                 {
27771                         p := &((*(*(struct {
27772                                 Type HUDType
27773
27774                                 Pos      [2]float32
27775                                 Name     string
27776                                 Scale    [2]float32
27777                                 Text     string
27778                                 Number   uint32
27779                                 Item     uint32
27780                                 Dir      uint32
27781                                 Align    [2]float32
27782                                 Offset   [2]float32
27783                                 WorldPos Pos
27784                                 Size     [2]int32
27785                                 ZIndex   int16
27786                                 Text2    string
27787                                 Style    uint32
27788                         }))(obj)).Pos)[local320]
27789                         *p = math.Float32frombits(read32(r))
27790                 }
27791         }
27792         var local321 []uint8
27793         var local322 uint16
27794         {
27795                 p := &local322
27796                 *p = read16(r)
27797         }
27798         (local321) = make([]uint8, local322)
27799         {
27800                 _, err := io.ReadFull(r, (local321)[:])
27801                 chk(err)
27802         }
27803         ((*(*(struct {
27804                 Type HUDType
27805
27806                 Pos      [2]float32
27807                 Name     string
27808                 Scale    [2]float32
27809                 Text     string
27810                 Number   uint32
27811                 Item     uint32
27812                 Dir      uint32
27813                 Align    [2]float32
27814                 Offset   [2]float32
27815                 WorldPos Pos
27816                 Size     [2]int32
27817                 ZIndex   int16
27818                 Text2    string
27819                 Style    uint32
27820         }))(obj)).Name) = string(local321)
27821         for local323 := range (*(*(struct {
27822                 Type HUDType
27823
27824                 Pos      [2]float32
27825                 Name     string
27826                 Scale    [2]float32
27827                 Text     string
27828                 Number   uint32
27829                 Item     uint32
27830                 Dir      uint32
27831                 Align    [2]float32
27832                 Offset   [2]float32
27833                 WorldPos Pos
27834                 Size     [2]int32
27835                 ZIndex   int16
27836                 Text2    string
27837                 Style    uint32
27838         }))(obj)).Scale {
27839                 {
27840                         p := &((*(*(struct {
27841                                 Type HUDType
27842
27843                                 Pos      [2]float32
27844                                 Name     string
27845                                 Scale    [2]float32
27846                                 Text     string
27847                                 Number   uint32
27848                                 Item     uint32
27849                                 Dir      uint32
27850                                 Align    [2]float32
27851                                 Offset   [2]float32
27852                                 WorldPos Pos
27853                                 Size     [2]int32
27854                                 ZIndex   int16
27855                                 Text2    string
27856                                 Style    uint32
27857                         }))(obj)).Scale)[local323]
27858                         *p = math.Float32frombits(read32(r))
27859                 }
27860         }
27861         var local324 []uint8
27862         var local325 uint16
27863         {
27864                 p := &local325
27865                 *p = read16(r)
27866         }
27867         (local324) = make([]uint8, local325)
27868         {
27869                 _, err := io.ReadFull(r, (local324)[:])
27870                 chk(err)
27871         }
27872         ((*(*(struct {
27873                 Type HUDType
27874
27875                 Pos      [2]float32
27876                 Name     string
27877                 Scale    [2]float32
27878                 Text     string
27879                 Number   uint32
27880                 Item     uint32
27881                 Dir      uint32
27882                 Align    [2]float32
27883                 Offset   [2]float32
27884                 WorldPos Pos
27885                 Size     [2]int32
27886                 ZIndex   int16
27887                 Text2    string
27888                 Style    uint32
27889         }))(obj)).Text) = string(local324)
27890         {
27891                 p := &(*(*(struct {
27892                         Type HUDType
27893
27894                         Pos      [2]float32
27895                         Name     string
27896                         Scale    [2]float32
27897                         Text     string
27898                         Number   uint32
27899                         Item     uint32
27900                         Dir      uint32
27901                         Align    [2]float32
27902                         Offset   [2]float32
27903                         WorldPos Pos
27904                         Size     [2]int32
27905                         ZIndex   int16
27906                         Text2    string
27907                         Style    uint32
27908                 }))(obj)).Number
27909                 *p = read32(r)
27910         }
27911         {
27912                 p := &(*(*(struct {
27913                         Type HUDType
27914
27915                         Pos      [2]float32
27916                         Name     string
27917                         Scale    [2]float32
27918                         Text     string
27919                         Number   uint32
27920                         Item     uint32
27921                         Dir      uint32
27922                         Align    [2]float32
27923                         Offset   [2]float32
27924                         WorldPos Pos
27925                         Size     [2]int32
27926                         ZIndex   int16
27927                         Text2    string
27928                         Style    uint32
27929                 }))(obj)).Item
27930                 *p = read32(r)
27931         }
27932         {
27933                 p := &(*(*(struct {
27934                         Type HUDType
27935
27936                         Pos      [2]float32
27937                         Name     string
27938                         Scale    [2]float32
27939                         Text     string
27940                         Number   uint32
27941                         Item     uint32
27942                         Dir      uint32
27943                         Align    [2]float32
27944                         Offset   [2]float32
27945                         WorldPos Pos
27946                         Size     [2]int32
27947                         ZIndex   int16
27948                         Text2    string
27949                         Style    uint32
27950                 }))(obj)).Dir
27951                 *p = read32(r)
27952         }
27953         for local326 := range (*(*(struct {
27954                 Type HUDType
27955
27956                 Pos      [2]float32
27957                 Name     string
27958                 Scale    [2]float32
27959                 Text     string
27960                 Number   uint32
27961                 Item     uint32
27962                 Dir      uint32
27963                 Align    [2]float32
27964                 Offset   [2]float32
27965                 WorldPos Pos
27966                 Size     [2]int32
27967                 ZIndex   int16
27968                 Text2    string
27969                 Style    uint32
27970         }))(obj)).Align {
27971                 {
27972                         p := &((*(*(struct {
27973                                 Type HUDType
27974
27975                                 Pos      [2]float32
27976                                 Name     string
27977                                 Scale    [2]float32
27978                                 Text     string
27979                                 Number   uint32
27980                                 Item     uint32
27981                                 Dir      uint32
27982                                 Align    [2]float32
27983                                 Offset   [2]float32
27984                                 WorldPos Pos
27985                                 Size     [2]int32
27986                                 ZIndex   int16
27987                                 Text2    string
27988                                 Style    uint32
27989                         }))(obj)).Align)[local326]
27990                         *p = math.Float32frombits(read32(r))
27991                 }
27992         }
27993         for local327 := range (*(*(struct {
27994                 Type HUDType
27995
27996                 Pos      [2]float32
27997                 Name     string
27998                 Scale    [2]float32
27999                 Text     string
28000                 Number   uint32
28001                 Item     uint32
28002                 Dir      uint32
28003                 Align    [2]float32
28004                 Offset   [2]float32
28005                 WorldPos Pos
28006                 Size     [2]int32
28007                 ZIndex   int16
28008                 Text2    string
28009                 Style    uint32
28010         }))(obj)).Offset {
28011                 {
28012                         p := &((*(*(struct {
28013                                 Type HUDType
28014
28015                                 Pos      [2]float32
28016                                 Name     string
28017                                 Scale    [2]float32
28018                                 Text     string
28019                                 Number   uint32
28020                                 Item     uint32
28021                                 Dir      uint32
28022                                 Align    [2]float32
28023                                 Offset   [2]float32
28024                                 WorldPos Pos
28025                                 Size     [2]int32
28026                                 ZIndex   int16
28027                                 Text2    string
28028                                 Style    uint32
28029                         }))(obj)).Offset)[local327]
28030                         *p = math.Float32frombits(read32(r))
28031                 }
28032         }
28033         if err := pcall(func() {
28034                 ((*(*(struct {
28035                         Type HUDType
28036
28037                         Pos      [2]float32
28038                         Name     string
28039                         Scale    [2]float32
28040                         Text     string
28041                         Number   uint32
28042                         Item     uint32
28043                         Dir      uint32
28044                         Align    [2]float32
28045                         Offset   [2]float32
28046                         WorldPos Pos
28047                         Size     [2]int32
28048                         ZIndex   int16
28049                         Text2    string
28050                         Style    uint32
28051                 }))(obj)).WorldPos).deserialize(r)
28052         }); err != nil {
28053                 if err == io.EOF {
28054                         chk(io.EOF)
28055                 }
28056                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
28057         }
28058         for local328 := range (*(*(struct {
28059                 Type HUDType
28060
28061                 Pos      [2]float32
28062                 Name     string
28063                 Scale    [2]float32
28064                 Text     string
28065                 Number   uint32
28066                 Item     uint32
28067                 Dir      uint32
28068                 Align    [2]float32
28069                 Offset   [2]float32
28070                 WorldPos Pos
28071                 Size     [2]int32
28072                 ZIndex   int16
28073                 Text2    string
28074                 Style    uint32
28075         }))(obj)).Size {
28076                 {
28077                         p := &((*(*(struct {
28078                                 Type HUDType
28079
28080                                 Pos      [2]float32
28081                                 Name     string
28082                                 Scale    [2]float32
28083                                 Text     string
28084                                 Number   uint32
28085                                 Item     uint32
28086                                 Dir      uint32
28087                                 Align    [2]float32
28088                                 Offset   [2]float32
28089                                 WorldPos Pos
28090                                 Size     [2]int32
28091                                 ZIndex   int16
28092                                 Text2    string
28093                                 Style    uint32
28094                         }))(obj)).Size)[local328]
28095                         *p = int32(read32(r))
28096                 }
28097         }
28098         {
28099                 p := &(*(*(struct {
28100                         Type HUDType
28101
28102                         Pos      [2]float32
28103                         Name     string
28104                         Scale    [2]float32
28105                         Text     string
28106                         Number   uint32
28107                         Item     uint32
28108                         Dir      uint32
28109                         Align    [2]float32
28110                         Offset   [2]float32
28111                         WorldPos Pos
28112                         Size     [2]int32
28113                         ZIndex   int16
28114                         Text2    string
28115                         Style    uint32
28116                 }))(obj)).ZIndex
28117                 *p = int16(read16(r))
28118         }
28119         var local329 []uint8
28120         var local330 uint16
28121         {
28122                 p := &local330
28123                 *p = read16(r)
28124         }
28125         (local329) = make([]uint8, local330)
28126         {
28127                 _, err := io.ReadFull(r, (local329)[:])
28128                 chk(err)
28129         }
28130         ((*(*(struct {
28131                 Type HUDType
28132
28133                 Pos      [2]float32
28134                 Name     string
28135                 Scale    [2]float32
28136                 Text     string
28137                 Number   uint32
28138                 Item     uint32
28139                 Dir      uint32
28140                 Align    [2]float32
28141                 Offset   [2]float32
28142                 WorldPos Pos
28143                 Size     [2]int32
28144                 ZIndex   int16
28145                 Text2    string
28146                 Style    uint32
28147         }))(obj)).Text2) = string(local329)
28148         {
28149                 p := &(*(*(struct {
28150                         Type HUDType
28151
28152                         Pos      [2]float32
28153                         Name     string
28154                         Scale    [2]float32
28155                         Text     string
28156                         Number   uint32
28157                         Item     uint32
28158                         Dir      uint32
28159                         Align    [2]float32
28160                         Offset   [2]float32
28161                         WorldPos Pos
28162                         Size     [2]int32
28163                         ZIndex   int16
28164                         Text2    string
28165                         Style    uint32
28166                 }))(obj)).Style
28167                 *p = read32(r)
28168         }
28169 }
28170
28171 func (obj *HUDField) serialize(w io.Writer) {
28172         {
28173                 x := *(*(uint8))(obj)
28174                 write8(w, uint8(x))
28175         }
28176 }
28177
28178 func (obj *HUDField) deserialize(r io.Reader) {
28179         {
28180                 p := &*(*(uint8))(obj)
28181                 *p = read8(r)
28182         }
28183 }
28184
28185 func (obj *HUDStyleFlags) serialize(w io.Writer) {
28186         {
28187                 x := *(*(uint32))(obj)
28188                 write32(w, uint32(x))
28189         }
28190 }
28191
28192 func (obj *HUDStyleFlags) deserialize(r io.Reader) {
28193         {
28194                 p := &*(*(uint32))(obj)
28195                 *p = read32(r)
28196         }
28197 }
28198
28199 func (obj *HUDFlags) serialize(w io.Writer) {
28200         {
28201                 x := *(*(uint32))(obj)
28202                 write32(w, uint32(x))
28203         }
28204 }
28205
28206 func (obj *HUDFlags) deserialize(r io.Reader) {
28207         {
28208                 p := &*(*(uint32))(obj)
28209                 *p = read32(r)
28210         }
28211 }
28212
28213 func (obj *HotbarParam) serialize(w io.Writer) {
28214         {
28215                 x := *(*(uint16))(obj)
28216                 write16(w, uint16(x))
28217         }
28218 }
28219
28220 func (obj *HotbarParam) deserialize(r io.Reader) {
28221         {
28222                 p := &*(*(uint16))(obj)
28223                 *p = read16(r)
28224         }
28225 }
28226
28227 func (obj *Texture) serialize(w io.Writer) {
28228         if len(([]byte(*(*(string))(obj)))) > math.MaxUint16 {
28229                 chk(ErrTooLong)
28230         }
28231         {
28232                 x := uint16(len(([]byte(*(*(string))(obj)))))
28233                 write16(w, uint16(x))
28234         }
28235         {
28236                 _, err := w.Write(([]byte(*(*(string))(obj)))[:])
28237                 chk(err)
28238         }
28239 }
28240
28241 func (obj *Texture) deserialize(r io.Reader) {
28242         var local331 []uint8
28243         var local332 uint16
28244         {
28245                 p := &local332
28246                 *p = read16(r)
28247         }
28248         (local331) = make([]uint8, local332)
28249         {
28250                 _, err := io.ReadFull(r, (local331)[:])
28251                 chk(err)
28252         }
28253         (*(*(string))(obj)) = string(local331)
28254 }
28255
28256 func (obj *PlayerListUpdateType) serialize(w io.Writer) {
28257         {
28258                 x := *(*(uint8))(obj)
28259                 write8(w, uint8(x))
28260         }
28261 }
28262
28263 func (obj *PlayerListUpdateType) deserialize(r io.Reader) {
28264         {
28265                 p := &*(*(uint8))(obj)
28266                 *p = read8(r)
28267         }
28268 }
28269
28270 func (obj *ModChanSig) serialize(w io.Writer) {
28271         {
28272                 x := *(*(uint8))(obj)
28273                 write8(w, uint8(x))
28274         }
28275 }
28276
28277 func (obj *ModChanSig) deserialize(r io.Reader) {
28278         {
28279                 p := &*(*(uint8))(obj)
28280                 *p = read8(r)
28281         }
28282 }
28283
28284 func (obj *AOProps) serialize(w io.Writer) {
28285         {
28286                 local333 := uint8(4)
28287                 {
28288                         x := local333
28289                         write8(w, uint8(x))
28290                 }
28291         }
28292         {
28293                 x := (*(*(struct {
28294                         MaxHP            uint16 // Player only.
28295                         CollideWithNodes bool
28296                         Weight           float32 // deprecated
28297                         ColBox, SelBox   Box
28298                         Pointable        bool
28299                         Visual           string
28300                         VisualSize       [3]float32
28301                         Textures         []Texture
28302                         SpriteSheetSize  [2]int16 // in sprites.
28303                         SpritePos        [2]int16 // in sprite sheet.
28304                         Visible          bool
28305                         MakeFootstepSnds bool
28306                         RotateSpeed      float32 // in radians per second.
28307                         Mesh             string
28308                         Colors           []color.NRGBA
28309                         CollideWithAOs   bool
28310                         StepHeight       float32
28311                         FaceRotateDir    bool
28312                         FaceRotateDirOff float32 // in degrees.
28313                         BackfaceCull     bool
28314                         Nametag          string
28315                         NametagColor     color.NRGBA
28316                         FaceRotateSpeed  float32 // in degrees per second.
28317                         Infotext         string
28318                         Itemstring       string
28319                         Glow             int8
28320                         MaxBreath        uint16  // Player only.
28321                         EyeHeight        float32 // Player only.
28322                         ZoomFOV          float32 // in degrees. Player only.
28323                         UseTextureAlpha  bool
28324                         DmgTextureMod    Texture // suffix
28325                         Shaded           bool
28326                         ShowOnMinimap    bool
28327                         NametagBG        color.NRGBA
28328                 }))(obj)).MaxHP
28329                 write16(w, uint16(x))
28330         }
28331         {
28332                 x := (*(*(struct {
28333                         MaxHP            uint16 // Player only.
28334                         CollideWithNodes bool
28335                         Weight           float32 // deprecated
28336                         ColBox, SelBox   Box
28337                         Pointable        bool
28338                         Visual           string
28339                         VisualSize       [3]float32
28340                         Textures         []Texture
28341                         SpriteSheetSize  [2]int16 // in sprites.
28342                         SpritePos        [2]int16 // in sprite sheet.
28343                         Visible          bool
28344                         MakeFootstepSnds bool
28345                         RotateSpeed      float32 // in radians per second.
28346                         Mesh             string
28347                         Colors           []color.NRGBA
28348                         CollideWithAOs   bool
28349                         StepHeight       float32
28350                         FaceRotateDir    bool
28351                         FaceRotateDirOff float32 // in degrees.
28352                         BackfaceCull     bool
28353                         Nametag          string
28354                         NametagColor     color.NRGBA
28355                         FaceRotateSpeed  float32 // in degrees per second.
28356                         Infotext         string
28357                         Itemstring       string
28358                         Glow             int8
28359                         MaxBreath        uint16  // Player only.
28360                         EyeHeight        float32 // Player only.
28361                         ZoomFOV          float32 // in degrees. Player only.
28362                         UseTextureAlpha  bool
28363                         DmgTextureMod    Texture // suffix
28364                         Shaded           bool
28365                         ShowOnMinimap    bool
28366                         NametagBG        color.NRGBA
28367                 }))(obj)).CollideWithNodes
28368                 if x {
28369                         write8(w, 1)
28370                 } else {
28371                         write8(w, 0)
28372                 }
28373         }
28374         {
28375                 x := (*(*(struct {
28376                         MaxHP            uint16 // Player only.
28377                         CollideWithNodes bool
28378                         Weight           float32 // deprecated
28379                         ColBox, SelBox   Box
28380                         Pointable        bool
28381                         Visual           string
28382                         VisualSize       [3]float32
28383                         Textures         []Texture
28384                         SpriteSheetSize  [2]int16 // in sprites.
28385                         SpritePos        [2]int16 // in sprite sheet.
28386                         Visible          bool
28387                         MakeFootstepSnds bool
28388                         RotateSpeed      float32 // in radians per second.
28389                         Mesh             string
28390                         Colors           []color.NRGBA
28391                         CollideWithAOs   bool
28392                         StepHeight       float32
28393                         FaceRotateDir    bool
28394                         FaceRotateDirOff float32 // in degrees.
28395                         BackfaceCull     bool
28396                         Nametag          string
28397                         NametagColor     color.NRGBA
28398                         FaceRotateSpeed  float32 // in degrees per second.
28399                         Infotext         string
28400                         Itemstring       string
28401                         Glow             int8
28402                         MaxBreath        uint16  // Player only.
28403                         EyeHeight        float32 // Player only.
28404                         ZoomFOV          float32 // in degrees. Player only.
28405                         UseTextureAlpha  bool
28406                         DmgTextureMod    Texture // suffix
28407                         Shaded           bool
28408                         ShowOnMinimap    bool
28409                         NametagBG        color.NRGBA
28410                 }))(obj)).Weight
28411                 write32(w, math.Float32bits(x))
28412         }
28413         if err := pcall(func() {
28414                 ((*(*(struct {
28415                         MaxHP            uint16 // Player only.
28416                         CollideWithNodes bool
28417                         Weight           float32 // deprecated
28418                         ColBox, SelBox   Box
28419                         Pointable        bool
28420                         Visual           string
28421                         VisualSize       [3]float32
28422                         Textures         []Texture
28423                         SpriteSheetSize  [2]int16 // in sprites.
28424                         SpritePos        [2]int16 // in sprite sheet.
28425                         Visible          bool
28426                         MakeFootstepSnds bool
28427                         RotateSpeed      float32 // in radians per second.
28428                         Mesh             string
28429                         Colors           []color.NRGBA
28430                         CollideWithAOs   bool
28431                         StepHeight       float32
28432                         FaceRotateDir    bool
28433                         FaceRotateDirOff float32 // in degrees.
28434                         BackfaceCull     bool
28435                         Nametag          string
28436                         NametagColor     color.NRGBA
28437                         FaceRotateSpeed  float32 // in degrees per second.
28438                         Infotext         string
28439                         Itemstring       string
28440                         Glow             int8
28441                         MaxBreath        uint16  // Player only.
28442                         EyeHeight        float32 // Player only.
28443                         ZoomFOV          float32 // in degrees. Player only.
28444                         UseTextureAlpha  bool
28445                         DmgTextureMod    Texture // suffix
28446                         Shaded           bool
28447                         ShowOnMinimap    bool
28448                         NametagBG        color.NRGBA
28449                 }))(obj)).ColBox).serialize(w)
28450         }); err != nil {
28451                 if err == io.EOF {
28452                         chk(io.EOF)
28453                 }
28454                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
28455         }
28456         if err := pcall(func() {
28457                 ((*(*(struct {
28458                         MaxHP            uint16 // Player only.
28459                         CollideWithNodes bool
28460                         Weight           float32 // deprecated
28461                         ColBox, SelBox   Box
28462                         Pointable        bool
28463                         Visual           string
28464                         VisualSize       [3]float32
28465                         Textures         []Texture
28466                         SpriteSheetSize  [2]int16 // in sprites.
28467                         SpritePos        [2]int16 // in sprite sheet.
28468                         Visible          bool
28469                         MakeFootstepSnds bool
28470                         RotateSpeed      float32 // in radians per second.
28471                         Mesh             string
28472                         Colors           []color.NRGBA
28473                         CollideWithAOs   bool
28474                         StepHeight       float32
28475                         FaceRotateDir    bool
28476                         FaceRotateDirOff float32 // in degrees.
28477                         BackfaceCull     bool
28478                         Nametag          string
28479                         NametagColor     color.NRGBA
28480                         FaceRotateSpeed  float32 // in degrees per second.
28481                         Infotext         string
28482                         Itemstring       string
28483                         Glow             int8
28484                         MaxBreath        uint16  // Player only.
28485                         EyeHeight        float32 // Player only.
28486                         ZoomFOV          float32 // in degrees. Player only.
28487                         UseTextureAlpha  bool
28488                         DmgTextureMod    Texture // suffix
28489                         Shaded           bool
28490                         ShowOnMinimap    bool
28491                         NametagBG        color.NRGBA
28492                 }))(obj)).SelBox).serialize(w)
28493         }); err != nil {
28494                 if err == io.EOF {
28495                         chk(io.EOF)
28496                 }
28497                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
28498         }
28499         {
28500                 x := (*(*(struct {
28501                         MaxHP            uint16 // Player only.
28502                         CollideWithNodes bool
28503                         Weight           float32 // deprecated
28504                         ColBox, SelBox   Box
28505                         Pointable        bool
28506                         Visual           string
28507                         VisualSize       [3]float32
28508                         Textures         []Texture
28509                         SpriteSheetSize  [2]int16 // in sprites.
28510                         SpritePos        [2]int16 // in sprite sheet.
28511                         Visible          bool
28512                         MakeFootstepSnds bool
28513                         RotateSpeed      float32 // in radians per second.
28514                         Mesh             string
28515                         Colors           []color.NRGBA
28516                         CollideWithAOs   bool
28517                         StepHeight       float32
28518                         FaceRotateDir    bool
28519                         FaceRotateDirOff float32 // in degrees.
28520                         BackfaceCull     bool
28521                         Nametag          string
28522                         NametagColor     color.NRGBA
28523                         FaceRotateSpeed  float32 // in degrees per second.
28524                         Infotext         string
28525                         Itemstring       string
28526                         Glow             int8
28527                         MaxBreath        uint16  // Player only.
28528                         EyeHeight        float32 // Player only.
28529                         ZoomFOV          float32 // in degrees. Player only.
28530                         UseTextureAlpha  bool
28531                         DmgTextureMod    Texture // suffix
28532                         Shaded           bool
28533                         ShowOnMinimap    bool
28534                         NametagBG        color.NRGBA
28535                 }))(obj)).Pointable
28536                 if x {
28537                         write8(w, 1)
28538                 } else {
28539                         write8(w, 0)
28540                 }
28541         }
28542         if len(([]byte((*(*(struct {
28543                 MaxHP            uint16 // Player only.
28544                 CollideWithNodes bool
28545                 Weight           float32 // deprecated
28546                 ColBox, SelBox   Box
28547                 Pointable        bool
28548                 Visual           string
28549                 VisualSize       [3]float32
28550                 Textures         []Texture
28551                 SpriteSheetSize  [2]int16 // in sprites.
28552                 SpritePos        [2]int16 // in sprite sheet.
28553                 Visible          bool
28554                 MakeFootstepSnds bool
28555                 RotateSpeed      float32 // in radians per second.
28556                 Mesh             string
28557                 Colors           []color.NRGBA
28558                 CollideWithAOs   bool
28559                 StepHeight       float32
28560                 FaceRotateDir    bool
28561                 FaceRotateDirOff float32 // in degrees.
28562                 BackfaceCull     bool
28563                 Nametag          string
28564                 NametagColor     color.NRGBA
28565                 FaceRotateSpeed  float32 // in degrees per second.
28566                 Infotext         string
28567                 Itemstring       string
28568                 Glow             int8
28569                 MaxBreath        uint16  // Player only.
28570                 EyeHeight        float32 // Player only.
28571                 ZoomFOV          float32 // in degrees. Player only.
28572                 UseTextureAlpha  bool
28573                 DmgTextureMod    Texture // suffix
28574                 Shaded           bool
28575                 ShowOnMinimap    bool
28576                 NametagBG        color.NRGBA
28577         }))(obj)).Visual))) > math.MaxUint16 {
28578                 chk(ErrTooLong)
28579         }
28580         {
28581                 x := uint16(len(([]byte((*(*(struct {
28582                         MaxHP            uint16 // Player only.
28583                         CollideWithNodes bool
28584                         Weight           float32 // deprecated
28585                         ColBox, SelBox   Box
28586                         Pointable        bool
28587                         Visual           string
28588                         VisualSize       [3]float32
28589                         Textures         []Texture
28590                         SpriteSheetSize  [2]int16 // in sprites.
28591                         SpritePos        [2]int16 // in sprite sheet.
28592                         Visible          bool
28593                         MakeFootstepSnds bool
28594                         RotateSpeed      float32 // in radians per second.
28595                         Mesh             string
28596                         Colors           []color.NRGBA
28597                         CollideWithAOs   bool
28598                         StepHeight       float32
28599                         FaceRotateDir    bool
28600                         FaceRotateDirOff float32 // in degrees.
28601                         BackfaceCull     bool
28602                         Nametag          string
28603                         NametagColor     color.NRGBA
28604                         FaceRotateSpeed  float32 // in degrees per second.
28605                         Infotext         string
28606                         Itemstring       string
28607                         Glow             int8
28608                         MaxBreath        uint16  // Player only.
28609                         EyeHeight        float32 // Player only.
28610                         ZoomFOV          float32 // in degrees. Player only.
28611                         UseTextureAlpha  bool
28612                         DmgTextureMod    Texture // suffix
28613                         Shaded           bool
28614                         ShowOnMinimap    bool
28615                         NametagBG        color.NRGBA
28616                 }))(obj)).Visual))))
28617                 write16(w, uint16(x))
28618         }
28619         {
28620                 _, err := w.Write(([]byte((*(*(struct {
28621                         MaxHP            uint16 // Player only.
28622                         CollideWithNodes bool
28623                         Weight           float32 // deprecated
28624                         ColBox, SelBox   Box
28625                         Pointable        bool
28626                         Visual           string
28627                         VisualSize       [3]float32
28628                         Textures         []Texture
28629                         SpriteSheetSize  [2]int16 // in sprites.
28630                         SpritePos        [2]int16 // in sprite sheet.
28631                         Visible          bool
28632                         MakeFootstepSnds bool
28633                         RotateSpeed      float32 // in radians per second.
28634                         Mesh             string
28635                         Colors           []color.NRGBA
28636                         CollideWithAOs   bool
28637                         StepHeight       float32
28638                         FaceRotateDir    bool
28639                         FaceRotateDirOff float32 // in degrees.
28640                         BackfaceCull     bool
28641                         Nametag          string
28642                         NametagColor     color.NRGBA
28643                         FaceRotateSpeed  float32 // in degrees per second.
28644                         Infotext         string
28645                         Itemstring       string
28646                         Glow             int8
28647                         MaxBreath        uint16  // Player only.
28648                         EyeHeight        float32 // Player only.
28649                         ZoomFOV          float32 // in degrees. Player only.
28650                         UseTextureAlpha  bool
28651                         DmgTextureMod    Texture // suffix
28652                         Shaded           bool
28653                         ShowOnMinimap    bool
28654                         NametagBG        color.NRGBA
28655                 }))(obj)).Visual))[:])
28656                 chk(err)
28657         }
28658         for local334 := range (*(*(struct {
28659                 MaxHP            uint16 // Player only.
28660                 CollideWithNodes bool
28661                 Weight           float32 // deprecated
28662                 ColBox, SelBox   Box
28663                 Pointable        bool
28664                 Visual           string
28665                 VisualSize       [3]float32
28666                 Textures         []Texture
28667                 SpriteSheetSize  [2]int16 // in sprites.
28668                 SpritePos        [2]int16 // in sprite sheet.
28669                 Visible          bool
28670                 MakeFootstepSnds bool
28671                 RotateSpeed      float32 // in radians per second.
28672                 Mesh             string
28673                 Colors           []color.NRGBA
28674                 CollideWithAOs   bool
28675                 StepHeight       float32
28676                 FaceRotateDir    bool
28677                 FaceRotateDirOff float32 // in degrees.
28678                 BackfaceCull     bool
28679                 Nametag          string
28680                 NametagColor     color.NRGBA
28681                 FaceRotateSpeed  float32 // in degrees per second.
28682                 Infotext         string
28683                 Itemstring       string
28684                 Glow             int8
28685                 MaxBreath        uint16  // Player only.
28686                 EyeHeight        float32 // Player only.
28687                 ZoomFOV          float32 // in degrees. Player only.
28688                 UseTextureAlpha  bool
28689                 DmgTextureMod    Texture // suffix
28690                 Shaded           bool
28691                 ShowOnMinimap    bool
28692                 NametagBG        color.NRGBA
28693         }))(obj)).VisualSize {
28694                 {
28695                         x := ((*(*(struct {
28696                                 MaxHP            uint16 // Player only.
28697                                 CollideWithNodes bool
28698                                 Weight           float32 // deprecated
28699                                 ColBox, SelBox   Box
28700                                 Pointable        bool
28701                                 Visual           string
28702                                 VisualSize       [3]float32
28703                                 Textures         []Texture
28704                                 SpriteSheetSize  [2]int16 // in sprites.
28705                                 SpritePos        [2]int16 // in sprite sheet.
28706                                 Visible          bool
28707                                 MakeFootstepSnds bool
28708                                 RotateSpeed      float32 // in radians per second.
28709                                 Mesh             string
28710                                 Colors           []color.NRGBA
28711                                 CollideWithAOs   bool
28712                                 StepHeight       float32
28713                                 FaceRotateDir    bool
28714                                 FaceRotateDirOff float32 // in degrees.
28715                                 BackfaceCull     bool
28716                                 Nametag          string
28717                                 NametagColor     color.NRGBA
28718                                 FaceRotateSpeed  float32 // in degrees per second.
28719                                 Infotext         string
28720                                 Itemstring       string
28721                                 Glow             int8
28722                                 MaxBreath        uint16  // Player only.
28723                                 EyeHeight        float32 // Player only.
28724                                 ZoomFOV          float32 // in degrees. Player only.
28725                                 UseTextureAlpha  bool
28726                                 DmgTextureMod    Texture // suffix
28727                                 Shaded           bool
28728                                 ShowOnMinimap    bool
28729                                 NametagBG        color.NRGBA
28730                         }))(obj)).VisualSize)[local334]
28731                         write32(w, math.Float32bits(x))
28732                 }
28733         }
28734         if len(((*(*(struct {
28735                 MaxHP            uint16 // Player only.
28736                 CollideWithNodes bool
28737                 Weight           float32 // deprecated
28738                 ColBox, SelBox   Box
28739                 Pointable        bool
28740                 Visual           string
28741                 VisualSize       [3]float32
28742                 Textures         []Texture
28743                 SpriteSheetSize  [2]int16 // in sprites.
28744                 SpritePos        [2]int16 // in sprite sheet.
28745                 Visible          bool
28746                 MakeFootstepSnds bool
28747                 RotateSpeed      float32 // in radians per second.
28748                 Mesh             string
28749                 Colors           []color.NRGBA
28750                 CollideWithAOs   bool
28751                 StepHeight       float32
28752                 FaceRotateDir    bool
28753                 FaceRotateDirOff float32 // in degrees.
28754                 BackfaceCull     bool
28755                 Nametag          string
28756                 NametagColor     color.NRGBA
28757                 FaceRotateSpeed  float32 // in degrees per second.
28758                 Infotext         string
28759                 Itemstring       string
28760                 Glow             int8
28761                 MaxBreath        uint16  // Player only.
28762                 EyeHeight        float32 // Player only.
28763                 ZoomFOV          float32 // in degrees. Player only.
28764                 UseTextureAlpha  bool
28765                 DmgTextureMod    Texture // suffix
28766                 Shaded           bool
28767                 ShowOnMinimap    bool
28768                 NametagBG        color.NRGBA
28769         }))(obj)).Textures)) > math.MaxUint16 {
28770                 chk(ErrTooLong)
28771         }
28772         {
28773                 x := uint16(len(((*(*(struct {
28774                         MaxHP            uint16 // Player only.
28775                         CollideWithNodes bool
28776                         Weight           float32 // deprecated
28777                         ColBox, SelBox   Box
28778                         Pointable        bool
28779                         Visual           string
28780                         VisualSize       [3]float32
28781                         Textures         []Texture
28782                         SpriteSheetSize  [2]int16 // in sprites.
28783                         SpritePos        [2]int16 // in sprite sheet.
28784                         Visible          bool
28785                         MakeFootstepSnds bool
28786                         RotateSpeed      float32 // in radians per second.
28787                         Mesh             string
28788                         Colors           []color.NRGBA
28789                         CollideWithAOs   bool
28790                         StepHeight       float32
28791                         FaceRotateDir    bool
28792                         FaceRotateDirOff float32 // in degrees.
28793                         BackfaceCull     bool
28794                         Nametag          string
28795                         NametagColor     color.NRGBA
28796                         FaceRotateSpeed  float32 // in degrees per second.
28797                         Infotext         string
28798                         Itemstring       string
28799                         Glow             int8
28800                         MaxBreath        uint16  // Player only.
28801                         EyeHeight        float32 // Player only.
28802                         ZoomFOV          float32 // in degrees. Player only.
28803                         UseTextureAlpha  bool
28804                         DmgTextureMod    Texture // suffix
28805                         Shaded           bool
28806                         ShowOnMinimap    bool
28807                         NametagBG        color.NRGBA
28808                 }))(obj)).Textures)))
28809                 write16(w, uint16(x))
28810         }
28811         for local335 := range (*(*(struct {
28812                 MaxHP            uint16 // Player only.
28813                 CollideWithNodes bool
28814                 Weight           float32 // deprecated
28815                 ColBox, SelBox   Box
28816                 Pointable        bool
28817                 Visual           string
28818                 VisualSize       [3]float32
28819                 Textures         []Texture
28820                 SpriteSheetSize  [2]int16 // in sprites.
28821                 SpritePos        [2]int16 // in sprite sheet.
28822                 Visible          bool
28823                 MakeFootstepSnds bool
28824                 RotateSpeed      float32 // in radians per second.
28825                 Mesh             string
28826                 Colors           []color.NRGBA
28827                 CollideWithAOs   bool
28828                 StepHeight       float32
28829                 FaceRotateDir    bool
28830                 FaceRotateDirOff float32 // in degrees.
28831                 BackfaceCull     bool
28832                 Nametag          string
28833                 NametagColor     color.NRGBA
28834                 FaceRotateSpeed  float32 // in degrees per second.
28835                 Infotext         string
28836                 Itemstring       string
28837                 Glow             int8
28838                 MaxBreath        uint16  // Player only.
28839                 EyeHeight        float32 // Player only.
28840                 ZoomFOV          float32 // in degrees. Player only.
28841                 UseTextureAlpha  bool
28842                 DmgTextureMod    Texture // suffix
28843                 Shaded           bool
28844                 ShowOnMinimap    bool
28845                 NametagBG        color.NRGBA
28846         }))(obj)).Textures {
28847                 if err := pcall(func() {
28848                         (((*(*(struct {
28849                                 MaxHP            uint16 // Player only.
28850                                 CollideWithNodes bool
28851                                 Weight           float32 // deprecated
28852                                 ColBox, SelBox   Box
28853                                 Pointable        bool
28854                                 Visual           string
28855                                 VisualSize       [3]float32
28856                                 Textures         []Texture
28857                                 SpriteSheetSize  [2]int16 // in sprites.
28858                                 SpritePos        [2]int16 // in sprite sheet.
28859                                 Visible          bool
28860                                 MakeFootstepSnds bool
28861                                 RotateSpeed      float32 // in radians per second.
28862                                 Mesh             string
28863                                 Colors           []color.NRGBA
28864                                 CollideWithAOs   bool
28865                                 StepHeight       float32
28866                                 FaceRotateDir    bool
28867                                 FaceRotateDirOff float32 // in degrees.
28868                                 BackfaceCull     bool
28869                                 Nametag          string
28870                                 NametagColor     color.NRGBA
28871                                 FaceRotateSpeed  float32 // in degrees per second.
28872                                 Infotext         string
28873                                 Itemstring       string
28874                                 Glow             int8
28875                                 MaxBreath        uint16  // Player only.
28876                                 EyeHeight        float32 // Player only.
28877                                 ZoomFOV          float32 // in degrees. Player only.
28878                                 UseTextureAlpha  bool
28879                                 DmgTextureMod    Texture // suffix
28880                                 Shaded           bool
28881                                 ShowOnMinimap    bool
28882                                 NametagBG        color.NRGBA
28883                         }))(obj)).Textures)[local335]).serialize(w)
28884                 }); err != nil {
28885                         if err == io.EOF {
28886                                 chk(io.EOF)
28887                         }
28888                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
28889                 }
28890         }
28891         for local336 := range (*(*(struct {
28892                 MaxHP            uint16 // Player only.
28893                 CollideWithNodes bool
28894                 Weight           float32 // deprecated
28895                 ColBox, SelBox   Box
28896                 Pointable        bool
28897                 Visual           string
28898                 VisualSize       [3]float32
28899                 Textures         []Texture
28900                 SpriteSheetSize  [2]int16 // in sprites.
28901                 SpritePos        [2]int16 // in sprite sheet.
28902                 Visible          bool
28903                 MakeFootstepSnds bool
28904                 RotateSpeed      float32 // in radians per second.
28905                 Mesh             string
28906                 Colors           []color.NRGBA
28907                 CollideWithAOs   bool
28908                 StepHeight       float32
28909                 FaceRotateDir    bool
28910                 FaceRotateDirOff float32 // in degrees.
28911                 BackfaceCull     bool
28912                 Nametag          string
28913                 NametagColor     color.NRGBA
28914                 FaceRotateSpeed  float32 // in degrees per second.
28915                 Infotext         string
28916                 Itemstring       string
28917                 Glow             int8
28918                 MaxBreath        uint16  // Player only.
28919                 EyeHeight        float32 // Player only.
28920                 ZoomFOV          float32 // in degrees. Player only.
28921                 UseTextureAlpha  bool
28922                 DmgTextureMod    Texture // suffix
28923                 Shaded           bool
28924                 ShowOnMinimap    bool
28925                 NametagBG        color.NRGBA
28926         }))(obj)).SpriteSheetSize {
28927                 {
28928                         x := ((*(*(struct {
28929                                 MaxHP            uint16 // Player only.
28930                                 CollideWithNodes bool
28931                                 Weight           float32 // deprecated
28932                                 ColBox, SelBox   Box
28933                                 Pointable        bool
28934                                 Visual           string
28935                                 VisualSize       [3]float32
28936                                 Textures         []Texture
28937                                 SpriteSheetSize  [2]int16 // in sprites.
28938                                 SpritePos        [2]int16 // in sprite sheet.
28939                                 Visible          bool
28940                                 MakeFootstepSnds bool
28941                                 RotateSpeed      float32 // in radians per second.
28942                                 Mesh             string
28943                                 Colors           []color.NRGBA
28944                                 CollideWithAOs   bool
28945                                 StepHeight       float32
28946                                 FaceRotateDir    bool
28947                                 FaceRotateDirOff float32 // in degrees.
28948                                 BackfaceCull     bool
28949                                 Nametag          string
28950                                 NametagColor     color.NRGBA
28951                                 FaceRotateSpeed  float32 // in degrees per second.
28952                                 Infotext         string
28953                                 Itemstring       string
28954                                 Glow             int8
28955                                 MaxBreath        uint16  // Player only.
28956                                 EyeHeight        float32 // Player only.
28957                                 ZoomFOV          float32 // in degrees. Player only.
28958                                 UseTextureAlpha  bool
28959                                 DmgTextureMod    Texture // suffix
28960                                 Shaded           bool
28961                                 ShowOnMinimap    bool
28962                                 NametagBG        color.NRGBA
28963                         }))(obj)).SpriteSheetSize)[local336]
28964                         write16(w, uint16(x))
28965                 }
28966         }
28967         for local337 := range (*(*(struct {
28968                 MaxHP            uint16 // Player only.
28969                 CollideWithNodes bool
28970                 Weight           float32 // deprecated
28971                 ColBox, SelBox   Box
28972                 Pointable        bool
28973                 Visual           string
28974                 VisualSize       [3]float32
28975                 Textures         []Texture
28976                 SpriteSheetSize  [2]int16 // in sprites.
28977                 SpritePos        [2]int16 // in sprite sheet.
28978                 Visible          bool
28979                 MakeFootstepSnds bool
28980                 RotateSpeed      float32 // in radians per second.
28981                 Mesh             string
28982                 Colors           []color.NRGBA
28983                 CollideWithAOs   bool
28984                 StepHeight       float32
28985                 FaceRotateDir    bool
28986                 FaceRotateDirOff float32 // in degrees.
28987                 BackfaceCull     bool
28988                 Nametag          string
28989                 NametagColor     color.NRGBA
28990                 FaceRotateSpeed  float32 // in degrees per second.
28991                 Infotext         string
28992                 Itemstring       string
28993                 Glow             int8
28994                 MaxBreath        uint16  // Player only.
28995                 EyeHeight        float32 // Player only.
28996                 ZoomFOV          float32 // in degrees. Player only.
28997                 UseTextureAlpha  bool
28998                 DmgTextureMod    Texture // suffix
28999                 Shaded           bool
29000                 ShowOnMinimap    bool
29001                 NametagBG        color.NRGBA
29002         }))(obj)).SpritePos {
29003                 {
29004                         x := ((*(*(struct {
29005                                 MaxHP            uint16 // Player only.
29006                                 CollideWithNodes bool
29007                                 Weight           float32 // deprecated
29008                                 ColBox, SelBox   Box
29009                                 Pointable        bool
29010                                 Visual           string
29011                                 VisualSize       [3]float32
29012                                 Textures         []Texture
29013                                 SpriteSheetSize  [2]int16 // in sprites.
29014                                 SpritePos        [2]int16 // in sprite sheet.
29015                                 Visible          bool
29016                                 MakeFootstepSnds bool
29017                                 RotateSpeed      float32 // in radians per second.
29018                                 Mesh             string
29019                                 Colors           []color.NRGBA
29020                                 CollideWithAOs   bool
29021                                 StepHeight       float32
29022                                 FaceRotateDir    bool
29023                                 FaceRotateDirOff float32 // in degrees.
29024                                 BackfaceCull     bool
29025                                 Nametag          string
29026                                 NametagColor     color.NRGBA
29027                                 FaceRotateSpeed  float32 // in degrees per second.
29028                                 Infotext         string
29029                                 Itemstring       string
29030                                 Glow             int8
29031                                 MaxBreath        uint16  // Player only.
29032                                 EyeHeight        float32 // Player only.
29033                                 ZoomFOV          float32 // in degrees. Player only.
29034                                 UseTextureAlpha  bool
29035                                 DmgTextureMod    Texture // suffix
29036                                 Shaded           bool
29037                                 ShowOnMinimap    bool
29038                                 NametagBG        color.NRGBA
29039                         }))(obj)).SpritePos)[local337]
29040                         write16(w, uint16(x))
29041                 }
29042         }
29043         {
29044                 x := (*(*(struct {
29045                         MaxHP            uint16 // Player only.
29046                         CollideWithNodes bool
29047                         Weight           float32 // deprecated
29048                         ColBox, SelBox   Box
29049                         Pointable        bool
29050                         Visual           string
29051                         VisualSize       [3]float32
29052                         Textures         []Texture
29053                         SpriteSheetSize  [2]int16 // in sprites.
29054                         SpritePos        [2]int16 // in sprite sheet.
29055                         Visible          bool
29056                         MakeFootstepSnds bool
29057                         RotateSpeed      float32 // in radians per second.
29058                         Mesh             string
29059                         Colors           []color.NRGBA
29060                         CollideWithAOs   bool
29061                         StepHeight       float32
29062                         FaceRotateDir    bool
29063                         FaceRotateDirOff float32 // in degrees.
29064                         BackfaceCull     bool
29065                         Nametag          string
29066                         NametagColor     color.NRGBA
29067                         FaceRotateSpeed  float32 // in degrees per second.
29068                         Infotext         string
29069                         Itemstring       string
29070                         Glow             int8
29071                         MaxBreath        uint16  // Player only.
29072                         EyeHeight        float32 // Player only.
29073                         ZoomFOV          float32 // in degrees. Player only.
29074                         UseTextureAlpha  bool
29075                         DmgTextureMod    Texture // suffix
29076                         Shaded           bool
29077                         ShowOnMinimap    bool
29078                         NametagBG        color.NRGBA
29079                 }))(obj)).Visible
29080                 if x {
29081                         write8(w, 1)
29082                 } else {
29083                         write8(w, 0)
29084                 }
29085         }
29086         {
29087                 x := (*(*(struct {
29088                         MaxHP            uint16 // Player only.
29089                         CollideWithNodes bool
29090                         Weight           float32 // deprecated
29091                         ColBox, SelBox   Box
29092                         Pointable        bool
29093                         Visual           string
29094                         VisualSize       [3]float32
29095                         Textures         []Texture
29096                         SpriteSheetSize  [2]int16 // in sprites.
29097                         SpritePos        [2]int16 // in sprite sheet.
29098                         Visible          bool
29099                         MakeFootstepSnds bool
29100                         RotateSpeed      float32 // in radians per second.
29101                         Mesh             string
29102                         Colors           []color.NRGBA
29103                         CollideWithAOs   bool
29104                         StepHeight       float32
29105                         FaceRotateDir    bool
29106                         FaceRotateDirOff float32 // in degrees.
29107                         BackfaceCull     bool
29108                         Nametag          string
29109                         NametagColor     color.NRGBA
29110                         FaceRotateSpeed  float32 // in degrees per second.
29111                         Infotext         string
29112                         Itemstring       string
29113                         Glow             int8
29114                         MaxBreath        uint16  // Player only.
29115                         EyeHeight        float32 // Player only.
29116                         ZoomFOV          float32 // in degrees. Player only.
29117                         UseTextureAlpha  bool
29118                         DmgTextureMod    Texture // suffix
29119                         Shaded           bool
29120                         ShowOnMinimap    bool
29121                         NametagBG        color.NRGBA
29122                 }))(obj)).MakeFootstepSnds
29123                 if x {
29124                         write8(w, 1)
29125                 } else {
29126                         write8(w, 0)
29127                 }
29128         }
29129         {
29130                 x := (*(*(struct {
29131                         MaxHP            uint16 // Player only.
29132                         CollideWithNodes bool
29133                         Weight           float32 // deprecated
29134                         ColBox, SelBox   Box
29135                         Pointable        bool
29136                         Visual           string
29137                         VisualSize       [3]float32
29138                         Textures         []Texture
29139                         SpriteSheetSize  [2]int16 // in sprites.
29140                         SpritePos        [2]int16 // in sprite sheet.
29141                         Visible          bool
29142                         MakeFootstepSnds bool
29143                         RotateSpeed      float32 // in radians per second.
29144                         Mesh             string
29145                         Colors           []color.NRGBA
29146                         CollideWithAOs   bool
29147                         StepHeight       float32
29148                         FaceRotateDir    bool
29149                         FaceRotateDirOff float32 // in degrees.
29150                         BackfaceCull     bool
29151                         Nametag          string
29152                         NametagColor     color.NRGBA
29153                         FaceRotateSpeed  float32 // in degrees per second.
29154                         Infotext         string
29155                         Itemstring       string
29156                         Glow             int8
29157                         MaxBreath        uint16  // Player only.
29158                         EyeHeight        float32 // Player only.
29159                         ZoomFOV          float32 // in degrees. Player only.
29160                         UseTextureAlpha  bool
29161                         DmgTextureMod    Texture // suffix
29162                         Shaded           bool
29163                         ShowOnMinimap    bool
29164                         NametagBG        color.NRGBA
29165                 }))(obj)).RotateSpeed
29166                 write32(w, math.Float32bits(x))
29167         }
29168         if len(([]byte((*(*(struct {
29169                 MaxHP            uint16 // Player only.
29170                 CollideWithNodes bool
29171                 Weight           float32 // deprecated
29172                 ColBox, SelBox   Box
29173                 Pointable        bool
29174                 Visual           string
29175                 VisualSize       [3]float32
29176                 Textures         []Texture
29177                 SpriteSheetSize  [2]int16 // in sprites.
29178                 SpritePos        [2]int16 // in sprite sheet.
29179                 Visible          bool
29180                 MakeFootstepSnds bool
29181                 RotateSpeed      float32 // in radians per second.
29182                 Mesh             string
29183                 Colors           []color.NRGBA
29184                 CollideWithAOs   bool
29185                 StepHeight       float32
29186                 FaceRotateDir    bool
29187                 FaceRotateDirOff float32 // in degrees.
29188                 BackfaceCull     bool
29189                 Nametag          string
29190                 NametagColor     color.NRGBA
29191                 FaceRotateSpeed  float32 // in degrees per second.
29192                 Infotext         string
29193                 Itemstring       string
29194                 Glow             int8
29195                 MaxBreath        uint16  // Player only.
29196                 EyeHeight        float32 // Player only.
29197                 ZoomFOV          float32 // in degrees. Player only.
29198                 UseTextureAlpha  bool
29199                 DmgTextureMod    Texture // suffix
29200                 Shaded           bool
29201                 ShowOnMinimap    bool
29202                 NametagBG        color.NRGBA
29203         }))(obj)).Mesh))) > math.MaxUint16 {
29204                 chk(ErrTooLong)
29205         }
29206         {
29207                 x := uint16(len(([]byte((*(*(struct {
29208                         MaxHP            uint16 // Player only.
29209                         CollideWithNodes bool
29210                         Weight           float32 // deprecated
29211                         ColBox, SelBox   Box
29212                         Pointable        bool
29213                         Visual           string
29214                         VisualSize       [3]float32
29215                         Textures         []Texture
29216                         SpriteSheetSize  [2]int16 // in sprites.
29217                         SpritePos        [2]int16 // in sprite sheet.
29218                         Visible          bool
29219                         MakeFootstepSnds bool
29220                         RotateSpeed      float32 // in radians per second.
29221                         Mesh             string
29222                         Colors           []color.NRGBA
29223                         CollideWithAOs   bool
29224                         StepHeight       float32
29225                         FaceRotateDir    bool
29226                         FaceRotateDirOff float32 // in degrees.
29227                         BackfaceCull     bool
29228                         Nametag          string
29229                         NametagColor     color.NRGBA
29230                         FaceRotateSpeed  float32 // in degrees per second.
29231                         Infotext         string
29232                         Itemstring       string
29233                         Glow             int8
29234                         MaxBreath        uint16  // Player only.
29235                         EyeHeight        float32 // Player only.
29236                         ZoomFOV          float32 // in degrees. Player only.
29237                         UseTextureAlpha  bool
29238                         DmgTextureMod    Texture // suffix
29239                         Shaded           bool
29240                         ShowOnMinimap    bool
29241                         NametagBG        color.NRGBA
29242                 }))(obj)).Mesh))))
29243                 write16(w, uint16(x))
29244         }
29245         {
29246                 _, err := w.Write(([]byte((*(*(struct {
29247                         MaxHP            uint16 // Player only.
29248                         CollideWithNodes bool
29249                         Weight           float32 // deprecated
29250                         ColBox, SelBox   Box
29251                         Pointable        bool
29252                         Visual           string
29253                         VisualSize       [3]float32
29254                         Textures         []Texture
29255                         SpriteSheetSize  [2]int16 // in sprites.
29256                         SpritePos        [2]int16 // in sprite sheet.
29257                         Visible          bool
29258                         MakeFootstepSnds bool
29259                         RotateSpeed      float32 // in radians per second.
29260                         Mesh             string
29261                         Colors           []color.NRGBA
29262                         CollideWithAOs   bool
29263                         StepHeight       float32
29264                         FaceRotateDir    bool
29265                         FaceRotateDirOff float32 // in degrees.
29266                         BackfaceCull     bool
29267                         Nametag          string
29268                         NametagColor     color.NRGBA
29269                         FaceRotateSpeed  float32 // in degrees per second.
29270                         Infotext         string
29271                         Itemstring       string
29272                         Glow             int8
29273                         MaxBreath        uint16  // Player only.
29274                         EyeHeight        float32 // Player only.
29275                         ZoomFOV          float32 // in degrees. Player only.
29276                         UseTextureAlpha  bool
29277                         DmgTextureMod    Texture // suffix
29278                         Shaded           bool
29279                         ShowOnMinimap    bool
29280                         NametagBG        color.NRGBA
29281                 }))(obj)).Mesh))[:])
29282                 chk(err)
29283         }
29284         if len(((*(*(struct {
29285                 MaxHP            uint16 // Player only.
29286                 CollideWithNodes bool
29287                 Weight           float32 // deprecated
29288                 ColBox, SelBox   Box
29289                 Pointable        bool
29290                 Visual           string
29291                 VisualSize       [3]float32
29292                 Textures         []Texture
29293                 SpriteSheetSize  [2]int16 // in sprites.
29294                 SpritePos        [2]int16 // in sprite sheet.
29295                 Visible          bool
29296                 MakeFootstepSnds bool
29297                 RotateSpeed      float32 // in radians per second.
29298                 Mesh             string
29299                 Colors           []color.NRGBA
29300                 CollideWithAOs   bool
29301                 StepHeight       float32
29302                 FaceRotateDir    bool
29303                 FaceRotateDirOff float32 // in degrees.
29304                 BackfaceCull     bool
29305                 Nametag          string
29306                 NametagColor     color.NRGBA
29307                 FaceRotateSpeed  float32 // in degrees per second.
29308                 Infotext         string
29309                 Itemstring       string
29310                 Glow             int8
29311                 MaxBreath        uint16  // Player only.
29312                 EyeHeight        float32 // Player only.
29313                 ZoomFOV          float32 // in degrees. Player only.
29314                 UseTextureAlpha  bool
29315                 DmgTextureMod    Texture // suffix
29316                 Shaded           bool
29317                 ShowOnMinimap    bool
29318                 NametagBG        color.NRGBA
29319         }))(obj)).Colors)) > math.MaxUint16 {
29320                 chk(ErrTooLong)
29321         }
29322         {
29323                 x := uint16(len(((*(*(struct {
29324                         MaxHP            uint16 // Player only.
29325                         CollideWithNodes bool
29326                         Weight           float32 // deprecated
29327                         ColBox, SelBox   Box
29328                         Pointable        bool
29329                         Visual           string
29330                         VisualSize       [3]float32
29331                         Textures         []Texture
29332                         SpriteSheetSize  [2]int16 // in sprites.
29333                         SpritePos        [2]int16 // in sprite sheet.
29334                         Visible          bool
29335                         MakeFootstepSnds bool
29336                         RotateSpeed      float32 // in radians per second.
29337                         Mesh             string
29338                         Colors           []color.NRGBA
29339                         CollideWithAOs   bool
29340                         StepHeight       float32
29341                         FaceRotateDir    bool
29342                         FaceRotateDirOff float32 // in degrees.
29343                         BackfaceCull     bool
29344                         Nametag          string
29345                         NametagColor     color.NRGBA
29346                         FaceRotateSpeed  float32 // in degrees per second.
29347                         Infotext         string
29348                         Itemstring       string
29349                         Glow             int8
29350                         MaxBreath        uint16  // Player only.
29351                         EyeHeight        float32 // Player only.
29352                         ZoomFOV          float32 // in degrees. Player only.
29353                         UseTextureAlpha  bool
29354                         DmgTextureMod    Texture // suffix
29355                         Shaded           bool
29356                         ShowOnMinimap    bool
29357                         NametagBG        color.NRGBA
29358                 }))(obj)).Colors)))
29359                 write16(w, uint16(x))
29360         }
29361         for local338 := range (*(*(struct {
29362                 MaxHP            uint16 // Player only.
29363                 CollideWithNodes bool
29364                 Weight           float32 // deprecated
29365                 ColBox, SelBox   Box
29366                 Pointable        bool
29367                 Visual           string
29368                 VisualSize       [3]float32
29369                 Textures         []Texture
29370                 SpriteSheetSize  [2]int16 // in sprites.
29371                 SpritePos        [2]int16 // in sprite sheet.
29372                 Visible          bool
29373                 MakeFootstepSnds bool
29374                 RotateSpeed      float32 // in radians per second.
29375                 Mesh             string
29376                 Colors           []color.NRGBA
29377                 CollideWithAOs   bool
29378                 StepHeight       float32
29379                 FaceRotateDir    bool
29380                 FaceRotateDirOff float32 // in degrees.
29381                 BackfaceCull     bool
29382                 Nametag          string
29383                 NametagColor     color.NRGBA
29384                 FaceRotateSpeed  float32 // in degrees per second.
29385                 Infotext         string
29386                 Itemstring       string
29387                 Glow             int8
29388                 MaxBreath        uint16  // Player only.
29389                 EyeHeight        float32 // Player only.
29390                 ZoomFOV          float32 // in degrees. Player only.
29391                 UseTextureAlpha  bool
29392                 DmgTextureMod    Texture // suffix
29393                 Shaded           bool
29394                 ShowOnMinimap    bool
29395                 NametagBG        color.NRGBA
29396         }))(obj)).Colors {
29397                 {
29398                         x := ((*(*(struct {
29399                                 MaxHP            uint16 // Player only.
29400                                 CollideWithNodes bool
29401                                 Weight           float32 // deprecated
29402                                 ColBox, SelBox   Box
29403                                 Pointable        bool
29404                                 Visual           string
29405                                 VisualSize       [3]float32
29406                                 Textures         []Texture
29407                                 SpriteSheetSize  [2]int16 // in sprites.
29408                                 SpritePos        [2]int16 // in sprite sheet.
29409                                 Visible          bool
29410                                 MakeFootstepSnds bool
29411                                 RotateSpeed      float32 // in radians per second.
29412                                 Mesh             string
29413                                 Colors           []color.NRGBA
29414                                 CollideWithAOs   bool
29415                                 StepHeight       float32
29416                                 FaceRotateDir    bool
29417                                 FaceRotateDirOff float32 // in degrees.
29418                                 BackfaceCull     bool
29419                                 Nametag          string
29420                                 NametagColor     color.NRGBA
29421                                 FaceRotateSpeed  float32 // in degrees per second.
29422                                 Infotext         string
29423                                 Itemstring       string
29424                                 Glow             int8
29425                                 MaxBreath        uint16  // Player only.
29426                                 EyeHeight        float32 // Player only.
29427                                 ZoomFOV          float32 // in degrees. Player only.
29428                                 UseTextureAlpha  bool
29429                                 DmgTextureMod    Texture // suffix
29430                                 Shaded           bool
29431                                 ShowOnMinimap    bool
29432                                 NametagBG        color.NRGBA
29433                         }))(obj)).Colors)[local338]
29434                         w.Write([]byte{x.A, x.R, x.G, x.B})
29435                 }
29436         }
29437         {
29438                 x := (*(*(struct {
29439                         MaxHP            uint16 // Player only.
29440                         CollideWithNodes bool
29441                         Weight           float32 // deprecated
29442                         ColBox, SelBox   Box
29443                         Pointable        bool
29444                         Visual           string
29445                         VisualSize       [3]float32
29446                         Textures         []Texture
29447                         SpriteSheetSize  [2]int16 // in sprites.
29448                         SpritePos        [2]int16 // in sprite sheet.
29449                         Visible          bool
29450                         MakeFootstepSnds bool
29451                         RotateSpeed      float32 // in radians per second.
29452                         Mesh             string
29453                         Colors           []color.NRGBA
29454                         CollideWithAOs   bool
29455                         StepHeight       float32
29456                         FaceRotateDir    bool
29457                         FaceRotateDirOff float32 // in degrees.
29458                         BackfaceCull     bool
29459                         Nametag          string
29460                         NametagColor     color.NRGBA
29461                         FaceRotateSpeed  float32 // in degrees per second.
29462                         Infotext         string
29463                         Itemstring       string
29464                         Glow             int8
29465                         MaxBreath        uint16  // Player only.
29466                         EyeHeight        float32 // Player only.
29467                         ZoomFOV          float32 // in degrees. Player only.
29468                         UseTextureAlpha  bool
29469                         DmgTextureMod    Texture // suffix
29470                         Shaded           bool
29471                         ShowOnMinimap    bool
29472                         NametagBG        color.NRGBA
29473                 }))(obj)).CollideWithAOs
29474                 if x {
29475                         write8(w, 1)
29476                 } else {
29477                         write8(w, 0)
29478                 }
29479         }
29480         {
29481                 x := (*(*(struct {
29482                         MaxHP            uint16 // Player only.
29483                         CollideWithNodes bool
29484                         Weight           float32 // deprecated
29485                         ColBox, SelBox   Box
29486                         Pointable        bool
29487                         Visual           string
29488                         VisualSize       [3]float32
29489                         Textures         []Texture
29490                         SpriteSheetSize  [2]int16 // in sprites.
29491                         SpritePos        [2]int16 // in sprite sheet.
29492                         Visible          bool
29493                         MakeFootstepSnds bool
29494                         RotateSpeed      float32 // in radians per second.
29495                         Mesh             string
29496                         Colors           []color.NRGBA
29497                         CollideWithAOs   bool
29498                         StepHeight       float32
29499                         FaceRotateDir    bool
29500                         FaceRotateDirOff float32 // in degrees.
29501                         BackfaceCull     bool
29502                         Nametag          string
29503                         NametagColor     color.NRGBA
29504                         FaceRotateSpeed  float32 // in degrees per second.
29505                         Infotext         string
29506                         Itemstring       string
29507                         Glow             int8
29508                         MaxBreath        uint16  // Player only.
29509                         EyeHeight        float32 // Player only.
29510                         ZoomFOV          float32 // in degrees. Player only.
29511                         UseTextureAlpha  bool
29512                         DmgTextureMod    Texture // suffix
29513                         Shaded           bool
29514                         ShowOnMinimap    bool
29515                         NametagBG        color.NRGBA
29516                 }))(obj)).StepHeight
29517                 write32(w, math.Float32bits(x))
29518         }
29519         {
29520                 x := (*(*(struct {
29521                         MaxHP            uint16 // Player only.
29522                         CollideWithNodes bool
29523                         Weight           float32 // deprecated
29524                         ColBox, SelBox   Box
29525                         Pointable        bool
29526                         Visual           string
29527                         VisualSize       [3]float32
29528                         Textures         []Texture
29529                         SpriteSheetSize  [2]int16 // in sprites.
29530                         SpritePos        [2]int16 // in sprite sheet.
29531                         Visible          bool
29532                         MakeFootstepSnds bool
29533                         RotateSpeed      float32 // in radians per second.
29534                         Mesh             string
29535                         Colors           []color.NRGBA
29536                         CollideWithAOs   bool
29537                         StepHeight       float32
29538                         FaceRotateDir    bool
29539                         FaceRotateDirOff float32 // in degrees.
29540                         BackfaceCull     bool
29541                         Nametag          string
29542                         NametagColor     color.NRGBA
29543                         FaceRotateSpeed  float32 // in degrees per second.
29544                         Infotext         string
29545                         Itemstring       string
29546                         Glow             int8
29547                         MaxBreath        uint16  // Player only.
29548                         EyeHeight        float32 // Player only.
29549                         ZoomFOV          float32 // in degrees. Player only.
29550                         UseTextureAlpha  bool
29551                         DmgTextureMod    Texture // suffix
29552                         Shaded           bool
29553                         ShowOnMinimap    bool
29554                         NametagBG        color.NRGBA
29555                 }))(obj)).FaceRotateDir
29556                 if x {
29557                         write8(w, 1)
29558                 } else {
29559                         write8(w, 0)
29560                 }
29561         }
29562         {
29563                 x := (*(*(struct {
29564                         MaxHP            uint16 // Player only.
29565                         CollideWithNodes bool
29566                         Weight           float32 // deprecated
29567                         ColBox, SelBox   Box
29568                         Pointable        bool
29569                         Visual           string
29570                         VisualSize       [3]float32
29571                         Textures         []Texture
29572                         SpriteSheetSize  [2]int16 // in sprites.
29573                         SpritePos        [2]int16 // in sprite sheet.
29574                         Visible          bool
29575                         MakeFootstepSnds bool
29576                         RotateSpeed      float32 // in radians per second.
29577                         Mesh             string
29578                         Colors           []color.NRGBA
29579                         CollideWithAOs   bool
29580                         StepHeight       float32
29581                         FaceRotateDir    bool
29582                         FaceRotateDirOff float32 // in degrees.
29583                         BackfaceCull     bool
29584                         Nametag          string
29585                         NametagColor     color.NRGBA
29586                         FaceRotateSpeed  float32 // in degrees per second.
29587                         Infotext         string
29588                         Itemstring       string
29589                         Glow             int8
29590                         MaxBreath        uint16  // Player only.
29591                         EyeHeight        float32 // Player only.
29592                         ZoomFOV          float32 // in degrees. Player only.
29593                         UseTextureAlpha  bool
29594                         DmgTextureMod    Texture // suffix
29595                         Shaded           bool
29596                         ShowOnMinimap    bool
29597                         NametagBG        color.NRGBA
29598                 }))(obj)).FaceRotateDirOff
29599                 write32(w, math.Float32bits(x))
29600         }
29601         {
29602                 x := (*(*(struct {
29603                         MaxHP            uint16 // Player only.
29604                         CollideWithNodes bool
29605                         Weight           float32 // deprecated
29606                         ColBox, SelBox   Box
29607                         Pointable        bool
29608                         Visual           string
29609                         VisualSize       [3]float32
29610                         Textures         []Texture
29611                         SpriteSheetSize  [2]int16 // in sprites.
29612                         SpritePos        [2]int16 // in sprite sheet.
29613                         Visible          bool
29614                         MakeFootstepSnds bool
29615                         RotateSpeed      float32 // in radians per second.
29616                         Mesh             string
29617                         Colors           []color.NRGBA
29618                         CollideWithAOs   bool
29619                         StepHeight       float32
29620                         FaceRotateDir    bool
29621                         FaceRotateDirOff float32 // in degrees.
29622                         BackfaceCull     bool
29623                         Nametag          string
29624                         NametagColor     color.NRGBA
29625                         FaceRotateSpeed  float32 // in degrees per second.
29626                         Infotext         string
29627                         Itemstring       string
29628                         Glow             int8
29629                         MaxBreath        uint16  // Player only.
29630                         EyeHeight        float32 // Player only.
29631                         ZoomFOV          float32 // in degrees. Player only.
29632                         UseTextureAlpha  bool
29633                         DmgTextureMod    Texture // suffix
29634                         Shaded           bool
29635                         ShowOnMinimap    bool
29636                         NametagBG        color.NRGBA
29637                 }))(obj)).BackfaceCull
29638                 if x {
29639                         write8(w, 1)
29640                 } else {
29641                         write8(w, 0)
29642                 }
29643         }
29644         if len(([]byte((*(*(struct {
29645                 MaxHP            uint16 // Player only.
29646                 CollideWithNodes bool
29647                 Weight           float32 // deprecated
29648                 ColBox, SelBox   Box
29649                 Pointable        bool
29650                 Visual           string
29651                 VisualSize       [3]float32
29652                 Textures         []Texture
29653                 SpriteSheetSize  [2]int16 // in sprites.
29654                 SpritePos        [2]int16 // in sprite sheet.
29655                 Visible          bool
29656                 MakeFootstepSnds bool
29657                 RotateSpeed      float32 // in radians per second.
29658                 Mesh             string
29659                 Colors           []color.NRGBA
29660                 CollideWithAOs   bool
29661                 StepHeight       float32
29662                 FaceRotateDir    bool
29663                 FaceRotateDirOff float32 // in degrees.
29664                 BackfaceCull     bool
29665                 Nametag          string
29666                 NametagColor     color.NRGBA
29667                 FaceRotateSpeed  float32 // in degrees per second.
29668                 Infotext         string
29669                 Itemstring       string
29670                 Glow             int8
29671                 MaxBreath        uint16  // Player only.
29672                 EyeHeight        float32 // Player only.
29673                 ZoomFOV          float32 // in degrees. Player only.
29674                 UseTextureAlpha  bool
29675                 DmgTextureMod    Texture // suffix
29676                 Shaded           bool
29677                 ShowOnMinimap    bool
29678                 NametagBG        color.NRGBA
29679         }))(obj)).Nametag))) > math.MaxUint16 {
29680                 chk(ErrTooLong)
29681         }
29682         {
29683                 x := uint16(len(([]byte((*(*(struct {
29684                         MaxHP            uint16 // Player only.
29685                         CollideWithNodes bool
29686                         Weight           float32 // deprecated
29687                         ColBox, SelBox   Box
29688                         Pointable        bool
29689                         Visual           string
29690                         VisualSize       [3]float32
29691                         Textures         []Texture
29692                         SpriteSheetSize  [2]int16 // in sprites.
29693                         SpritePos        [2]int16 // in sprite sheet.
29694                         Visible          bool
29695                         MakeFootstepSnds bool
29696                         RotateSpeed      float32 // in radians per second.
29697                         Mesh             string
29698                         Colors           []color.NRGBA
29699                         CollideWithAOs   bool
29700                         StepHeight       float32
29701                         FaceRotateDir    bool
29702                         FaceRotateDirOff float32 // in degrees.
29703                         BackfaceCull     bool
29704                         Nametag          string
29705                         NametagColor     color.NRGBA
29706                         FaceRotateSpeed  float32 // in degrees per second.
29707                         Infotext         string
29708                         Itemstring       string
29709                         Glow             int8
29710                         MaxBreath        uint16  // Player only.
29711                         EyeHeight        float32 // Player only.
29712                         ZoomFOV          float32 // in degrees. Player only.
29713                         UseTextureAlpha  bool
29714                         DmgTextureMod    Texture // suffix
29715                         Shaded           bool
29716                         ShowOnMinimap    bool
29717                         NametagBG        color.NRGBA
29718                 }))(obj)).Nametag))))
29719                 write16(w, uint16(x))
29720         }
29721         {
29722                 _, err := w.Write(([]byte((*(*(struct {
29723                         MaxHP            uint16 // Player only.
29724                         CollideWithNodes bool
29725                         Weight           float32 // deprecated
29726                         ColBox, SelBox   Box
29727                         Pointable        bool
29728                         Visual           string
29729                         VisualSize       [3]float32
29730                         Textures         []Texture
29731                         SpriteSheetSize  [2]int16 // in sprites.
29732                         SpritePos        [2]int16 // in sprite sheet.
29733                         Visible          bool
29734                         MakeFootstepSnds bool
29735                         RotateSpeed      float32 // in radians per second.
29736                         Mesh             string
29737                         Colors           []color.NRGBA
29738                         CollideWithAOs   bool
29739                         StepHeight       float32
29740                         FaceRotateDir    bool
29741                         FaceRotateDirOff float32 // in degrees.
29742                         BackfaceCull     bool
29743                         Nametag          string
29744                         NametagColor     color.NRGBA
29745                         FaceRotateSpeed  float32 // in degrees per second.
29746                         Infotext         string
29747                         Itemstring       string
29748                         Glow             int8
29749                         MaxBreath        uint16  // Player only.
29750                         EyeHeight        float32 // Player only.
29751                         ZoomFOV          float32 // in degrees. Player only.
29752                         UseTextureAlpha  bool
29753                         DmgTextureMod    Texture // suffix
29754                         Shaded           bool
29755                         ShowOnMinimap    bool
29756                         NametagBG        color.NRGBA
29757                 }))(obj)).Nametag))[:])
29758                 chk(err)
29759         }
29760         {
29761                 x := (*(*(struct {
29762                         MaxHP            uint16 // Player only.
29763                         CollideWithNodes bool
29764                         Weight           float32 // deprecated
29765                         ColBox, SelBox   Box
29766                         Pointable        bool
29767                         Visual           string
29768                         VisualSize       [3]float32
29769                         Textures         []Texture
29770                         SpriteSheetSize  [2]int16 // in sprites.
29771                         SpritePos        [2]int16 // in sprite sheet.
29772                         Visible          bool
29773                         MakeFootstepSnds bool
29774                         RotateSpeed      float32 // in radians per second.
29775                         Mesh             string
29776                         Colors           []color.NRGBA
29777                         CollideWithAOs   bool
29778                         StepHeight       float32
29779                         FaceRotateDir    bool
29780                         FaceRotateDirOff float32 // in degrees.
29781                         BackfaceCull     bool
29782                         Nametag          string
29783                         NametagColor     color.NRGBA
29784                         FaceRotateSpeed  float32 // in degrees per second.
29785                         Infotext         string
29786                         Itemstring       string
29787                         Glow             int8
29788                         MaxBreath        uint16  // Player only.
29789                         EyeHeight        float32 // Player only.
29790                         ZoomFOV          float32 // in degrees. Player only.
29791                         UseTextureAlpha  bool
29792                         DmgTextureMod    Texture // suffix
29793                         Shaded           bool
29794                         ShowOnMinimap    bool
29795                         NametagBG        color.NRGBA
29796                 }))(obj)).NametagColor
29797                 w.Write([]byte{x.A, x.R, x.G, x.B})
29798         }
29799         {
29800                 x := (*(*(struct {
29801                         MaxHP            uint16 // Player only.
29802                         CollideWithNodes bool
29803                         Weight           float32 // deprecated
29804                         ColBox, SelBox   Box
29805                         Pointable        bool
29806                         Visual           string
29807                         VisualSize       [3]float32
29808                         Textures         []Texture
29809                         SpriteSheetSize  [2]int16 // in sprites.
29810                         SpritePos        [2]int16 // in sprite sheet.
29811                         Visible          bool
29812                         MakeFootstepSnds bool
29813                         RotateSpeed      float32 // in radians per second.
29814                         Mesh             string
29815                         Colors           []color.NRGBA
29816                         CollideWithAOs   bool
29817                         StepHeight       float32
29818                         FaceRotateDir    bool
29819                         FaceRotateDirOff float32 // in degrees.
29820                         BackfaceCull     bool
29821                         Nametag          string
29822                         NametagColor     color.NRGBA
29823                         FaceRotateSpeed  float32 // in degrees per second.
29824                         Infotext         string
29825                         Itemstring       string
29826                         Glow             int8
29827                         MaxBreath        uint16  // Player only.
29828                         EyeHeight        float32 // Player only.
29829                         ZoomFOV          float32 // in degrees. Player only.
29830                         UseTextureAlpha  bool
29831                         DmgTextureMod    Texture // suffix
29832                         Shaded           bool
29833                         ShowOnMinimap    bool
29834                         NametagBG        color.NRGBA
29835                 }))(obj)).FaceRotateSpeed
29836                 write32(w, math.Float32bits(x))
29837         }
29838         if len(([]byte((*(*(struct {
29839                 MaxHP            uint16 // Player only.
29840                 CollideWithNodes bool
29841                 Weight           float32 // deprecated
29842                 ColBox, SelBox   Box
29843                 Pointable        bool
29844                 Visual           string
29845                 VisualSize       [3]float32
29846                 Textures         []Texture
29847                 SpriteSheetSize  [2]int16 // in sprites.
29848                 SpritePos        [2]int16 // in sprite sheet.
29849                 Visible          bool
29850                 MakeFootstepSnds bool
29851                 RotateSpeed      float32 // in radians per second.
29852                 Mesh             string
29853                 Colors           []color.NRGBA
29854                 CollideWithAOs   bool
29855                 StepHeight       float32
29856                 FaceRotateDir    bool
29857                 FaceRotateDirOff float32 // in degrees.
29858                 BackfaceCull     bool
29859                 Nametag          string
29860                 NametagColor     color.NRGBA
29861                 FaceRotateSpeed  float32 // in degrees per second.
29862                 Infotext         string
29863                 Itemstring       string
29864                 Glow             int8
29865                 MaxBreath        uint16  // Player only.
29866                 EyeHeight        float32 // Player only.
29867                 ZoomFOV          float32 // in degrees. Player only.
29868                 UseTextureAlpha  bool
29869                 DmgTextureMod    Texture // suffix
29870                 Shaded           bool
29871                 ShowOnMinimap    bool
29872                 NametagBG        color.NRGBA
29873         }))(obj)).Infotext))) > math.MaxUint16 {
29874                 chk(ErrTooLong)
29875         }
29876         {
29877                 x := uint16(len(([]byte((*(*(struct {
29878                         MaxHP            uint16 // Player only.
29879                         CollideWithNodes bool
29880                         Weight           float32 // deprecated
29881                         ColBox, SelBox   Box
29882                         Pointable        bool
29883                         Visual           string
29884                         VisualSize       [3]float32
29885                         Textures         []Texture
29886                         SpriteSheetSize  [2]int16 // in sprites.
29887                         SpritePos        [2]int16 // in sprite sheet.
29888                         Visible          bool
29889                         MakeFootstepSnds bool
29890                         RotateSpeed      float32 // in radians per second.
29891                         Mesh             string
29892                         Colors           []color.NRGBA
29893                         CollideWithAOs   bool
29894                         StepHeight       float32
29895                         FaceRotateDir    bool
29896                         FaceRotateDirOff float32 // in degrees.
29897                         BackfaceCull     bool
29898                         Nametag          string
29899                         NametagColor     color.NRGBA
29900                         FaceRotateSpeed  float32 // in degrees per second.
29901                         Infotext         string
29902                         Itemstring       string
29903                         Glow             int8
29904                         MaxBreath        uint16  // Player only.
29905                         EyeHeight        float32 // Player only.
29906                         ZoomFOV          float32 // in degrees. Player only.
29907                         UseTextureAlpha  bool
29908                         DmgTextureMod    Texture // suffix
29909                         Shaded           bool
29910                         ShowOnMinimap    bool
29911                         NametagBG        color.NRGBA
29912                 }))(obj)).Infotext))))
29913                 write16(w, uint16(x))
29914         }
29915         {
29916                 _, err := w.Write(([]byte((*(*(struct {
29917                         MaxHP            uint16 // Player only.
29918                         CollideWithNodes bool
29919                         Weight           float32 // deprecated
29920                         ColBox, SelBox   Box
29921                         Pointable        bool
29922                         Visual           string
29923                         VisualSize       [3]float32
29924                         Textures         []Texture
29925                         SpriteSheetSize  [2]int16 // in sprites.
29926                         SpritePos        [2]int16 // in sprite sheet.
29927                         Visible          bool
29928                         MakeFootstepSnds bool
29929                         RotateSpeed      float32 // in radians per second.
29930                         Mesh             string
29931                         Colors           []color.NRGBA
29932                         CollideWithAOs   bool
29933                         StepHeight       float32
29934                         FaceRotateDir    bool
29935                         FaceRotateDirOff float32 // in degrees.
29936                         BackfaceCull     bool
29937                         Nametag          string
29938                         NametagColor     color.NRGBA
29939                         FaceRotateSpeed  float32 // in degrees per second.
29940                         Infotext         string
29941                         Itemstring       string
29942                         Glow             int8
29943                         MaxBreath        uint16  // Player only.
29944                         EyeHeight        float32 // Player only.
29945                         ZoomFOV          float32 // in degrees. Player only.
29946                         UseTextureAlpha  bool
29947                         DmgTextureMod    Texture // suffix
29948                         Shaded           bool
29949                         ShowOnMinimap    bool
29950                         NametagBG        color.NRGBA
29951                 }))(obj)).Infotext))[:])
29952                 chk(err)
29953         }
29954         if len(([]byte((*(*(struct {
29955                 MaxHP            uint16 // Player only.
29956                 CollideWithNodes bool
29957                 Weight           float32 // deprecated
29958                 ColBox, SelBox   Box
29959                 Pointable        bool
29960                 Visual           string
29961                 VisualSize       [3]float32
29962                 Textures         []Texture
29963                 SpriteSheetSize  [2]int16 // in sprites.
29964                 SpritePos        [2]int16 // in sprite sheet.
29965                 Visible          bool
29966                 MakeFootstepSnds bool
29967                 RotateSpeed      float32 // in radians per second.
29968                 Mesh             string
29969                 Colors           []color.NRGBA
29970                 CollideWithAOs   bool
29971                 StepHeight       float32
29972                 FaceRotateDir    bool
29973                 FaceRotateDirOff float32 // in degrees.
29974                 BackfaceCull     bool
29975                 Nametag          string
29976                 NametagColor     color.NRGBA
29977                 FaceRotateSpeed  float32 // in degrees per second.
29978                 Infotext         string
29979                 Itemstring       string
29980                 Glow             int8
29981                 MaxBreath        uint16  // Player only.
29982                 EyeHeight        float32 // Player only.
29983                 ZoomFOV          float32 // in degrees. Player only.
29984                 UseTextureAlpha  bool
29985                 DmgTextureMod    Texture // suffix
29986                 Shaded           bool
29987                 ShowOnMinimap    bool
29988                 NametagBG        color.NRGBA
29989         }))(obj)).Itemstring))) > math.MaxUint16 {
29990                 chk(ErrTooLong)
29991         }
29992         {
29993                 x := uint16(len(([]byte((*(*(struct {
29994                         MaxHP            uint16 // Player only.
29995                         CollideWithNodes bool
29996                         Weight           float32 // deprecated
29997                         ColBox, SelBox   Box
29998                         Pointable        bool
29999                         Visual           string
30000                         VisualSize       [3]float32
30001                         Textures         []Texture
30002                         SpriteSheetSize  [2]int16 // in sprites.
30003                         SpritePos        [2]int16 // in sprite sheet.
30004                         Visible          bool
30005                         MakeFootstepSnds bool
30006                         RotateSpeed      float32 // in radians per second.
30007                         Mesh             string
30008                         Colors           []color.NRGBA
30009                         CollideWithAOs   bool
30010                         StepHeight       float32
30011                         FaceRotateDir    bool
30012                         FaceRotateDirOff float32 // in degrees.
30013                         BackfaceCull     bool
30014                         Nametag          string
30015                         NametagColor     color.NRGBA
30016                         FaceRotateSpeed  float32 // in degrees per second.
30017                         Infotext         string
30018                         Itemstring       string
30019                         Glow             int8
30020                         MaxBreath        uint16  // Player only.
30021                         EyeHeight        float32 // Player only.
30022                         ZoomFOV          float32 // in degrees. Player only.
30023                         UseTextureAlpha  bool
30024                         DmgTextureMod    Texture // suffix
30025                         Shaded           bool
30026                         ShowOnMinimap    bool
30027                         NametagBG        color.NRGBA
30028                 }))(obj)).Itemstring))))
30029                 write16(w, uint16(x))
30030         }
30031         {
30032                 _, err := w.Write(([]byte((*(*(struct {
30033                         MaxHP            uint16 // Player only.
30034                         CollideWithNodes bool
30035                         Weight           float32 // deprecated
30036                         ColBox, SelBox   Box
30037                         Pointable        bool
30038                         Visual           string
30039                         VisualSize       [3]float32
30040                         Textures         []Texture
30041                         SpriteSheetSize  [2]int16 // in sprites.
30042                         SpritePos        [2]int16 // in sprite sheet.
30043                         Visible          bool
30044                         MakeFootstepSnds bool
30045                         RotateSpeed      float32 // in radians per second.
30046                         Mesh             string
30047                         Colors           []color.NRGBA
30048                         CollideWithAOs   bool
30049                         StepHeight       float32
30050                         FaceRotateDir    bool
30051                         FaceRotateDirOff float32 // in degrees.
30052                         BackfaceCull     bool
30053                         Nametag          string
30054                         NametagColor     color.NRGBA
30055                         FaceRotateSpeed  float32 // in degrees per second.
30056                         Infotext         string
30057                         Itemstring       string
30058                         Glow             int8
30059                         MaxBreath        uint16  // Player only.
30060                         EyeHeight        float32 // Player only.
30061                         ZoomFOV          float32 // in degrees. Player only.
30062                         UseTextureAlpha  bool
30063                         DmgTextureMod    Texture // suffix
30064                         Shaded           bool
30065                         ShowOnMinimap    bool
30066                         NametagBG        color.NRGBA
30067                 }))(obj)).Itemstring))[:])
30068                 chk(err)
30069         }
30070         {
30071                 x := (*(*(struct {
30072                         MaxHP            uint16 // Player only.
30073                         CollideWithNodes bool
30074                         Weight           float32 // deprecated
30075                         ColBox, SelBox   Box
30076                         Pointable        bool
30077                         Visual           string
30078                         VisualSize       [3]float32
30079                         Textures         []Texture
30080                         SpriteSheetSize  [2]int16 // in sprites.
30081                         SpritePos        [2]int16 // in sprite sheet.
30082                         Visible          bool
30083                         MakeFootstepSnds bool
30084                         RotateSpeed      float32 // in radians per second.
30085                         Mesh             string
30086                         Colors           []color.NRGBA
30087                         CollideWithAOs   bool
30088                         StepHeight       float32
30089                         FaceRotateDir    bool
30090                         FaceRotateDirOff float32 // in degrees.
30091                         BackfaceCull     bool
30092                         Nametag          string
30093                         NametagColor     color.NRGBA
30094                         FaceRotateSpeed  float32 // in degrees per second.
30095                         Infotext         string
30096                         Itemstring       string
30097                         Glow             int8
30098                         MaxBreath        uint16  // Player only.
30099                         EyeHeight        float32 // Player only.
30100                         ZoomFOV          float32 // in degrees. Player only.
30101                         UseTextureAlpha  bool
30102                         DmgTextureMod    Texture // suffix
30103                         Shaded           bool
30104                         ShowOnMinimap    bool
30105                         NametagBG        color.NRGBA
30106                 }))(obj)).Glow
30107                 write8(w, uint8(x))
30108         }
30109         {
30110                 x := (*(*(struct {
30111                         MaxHP            uint16 // Player only.
30112                         CollideWithNodes bool
30113                         Weight           float32 // deprecated
30114                         ColBox, SelBox   Box
30115                         Pointable        bool
30116                         Visual           string
30117                         VisualSize       [3]float32
30118                         Textures         []Texture
30119                         SpriteSheetSize  [2]int16 // in sprites.
30120                         SpritePos        [2]int16 // in sprite sheet.
30121                         Visible          bool
30122                         MakeFootstepSnds bool
30123                         RotateSpeed      float32 // in radians per second.
30124                         Mesh             string
30125                         Colors           []color.NRGBA
30126                         CollideWithAOs   bool
30127                         StepHeight       float32
30128                         FaceRotateDir    bool
30129                         FaceRotateDirOff float32 // in degrees.
30130                         BackfaceCull     bool
30131                         Nametag          string
30132                         NametagColor     color.NRGBA
30133                         FaceRotateSpeed  float32 // in degrees per second.
30134                         Infotext         string
30135                         Itemstring       string
30136                         Glow             int8
30137                         MaxBreath        uint16  // Player only.
30138                         EyeHeight        float32 // Player only.
30139                         ZoomFOV          float32 // in degrees. Player only.
30140                         UseTextureAlpha  bool
30141                         DmgTextureMod    Texture // suffix
30142                         Shaded           bool
30143                         ShowOnMinimap    bool
30144                         NametagBG        color.NRGBA
30145                 }))(obj)).MaxBreath
30146                 write16(w, uint16(x))
30147         }
30148         {
30149                 x := (*(*(struct {
30150                         MaxHP            uint16 // Player only.
30151                         CollideWithNodes bool
30152                         Weight           float32 // deprecated
30153                         ColBox, SelBox   Box
30154                         Pointable        bool
30155                         Visual           string
30156                         VisualSize       [3]float32
30157                         Textures         []Texture
30158                         SpriteSheetSize  [2]int16 // in sprites.
30159                         SpritePos        [2]int16 // in sprite sheet.
30160                         Visible          bool
30161                         MakeFootstepSnds bool
30162                         RotateSpeed      float32 // in radians per second.
30163                         Mesh             string
30164                         Colors           []color.NRGBA
30165                         CollideWithAOs   bool
30166                         StepHeight       float32
30167                         FaceRotateDir    bool
30168                         FaceRotateDirOff float32 // in degrees.
30169                         BackfaceCull     bool
30170                         Nametag          string
30171                         NametagColor     color.NRGBA
30172                         FaceRotateSpeed  float32 // in degrees per second.
30173                         Infotext         string
30174                         Itemstring       string
30175                         Glow             int8
30176                         MaxBreath        uint16  // Player only.
30177                         EyeHeight        float32 // Player only.
30178                         ZoomFOV          float32 // in degrees. Player only.
30179                         UseTextureAlpha  bool
30180                         DmgTextureMod    Texture // suffix
30181                         Shaded           bool
30182                         ShowOnMinimap    bool
30183                         NametagBG        color.NRGBA
30184                 }))(obj)).EyeHeight
30185                 write32(w, math.Float32bits(x))
30186         }
30187         {
30188                 x := (*(*(struct {
30189                         MaxHP            uint16 // Player only.
30190                         CollideWithNodes bool
30191                         Weight           float32 // deprecated
30192                         ColBox, SelBox   Box
30193                         Pointable        bool
30194                         Visual           string
30195                         VisualSize       [3]float32
30196                         Textures         []Texture
30197                         SpriteSheetSize  [2]int16 // in sprites.
30198                         SpritePos        [2]int16 // in sprite sheet.
30199                         Visible          bool
30200                         MakeFootstepSnds bool
30201                         RotateSpeed      float32 // in radians per second.
30202                         Mesh             string
30203                         Colors           []color.NRGBA
30204                         CollideWithAOs   bool
30205                         StepHeight       float32
30206                         FaceRotateDir    bool
30207                         FaceRotateDirOff float32 // in degrees.
30208                         BackfaceCull     bool
30209                         Nametag          string
30210                         NametagColor     color.NRGBA
30211                         FaceRotateSpeed  float32 // in degrees per second.
30212                         Infotext         string
30213                         Itemstring       string
30214                         Glow             int8
30215                         MaxBreath        uint16  // Player only.
30216                         EyeHeight        float32 // Player only.
30217                         ZoomFOV          float32 // in degrees. Player only.
30218                         UseTextureAlpha  bool
30219                         DmgTextureMod    Texture // suffix
30220                         Shaded           bool
30221                         ShowOnMinimap    bool
30222                         NametagBG        color.NRGBA
30223                 }))(obj)).ZoomFOV
30224                 write32(w, math.Float32bits(x))
30225         }
30226         {
30227                 x := (*(*(struct {
30228                         MaxHP            uint16 // Player only.
30229                         CollideWithNodes bool
30230                         Weight           float32 // deprecated
30231                         ColBox, SelBox   Box
30232                         Pointable        bool
30233                         Visual           string
30234                         VisualSize       [3]float32
30235                         Textures         []Texture
30236                         SpriteSheetSize  [2]int16 // in sprites.
30237                         SpritePos        [2]int16 // in sprite sheet.
30238                         Visible          bool
30239                         MakeFootstepSnds bool
30240                         RotateSpeed      float32 // in radians per second.
30241                         Mesh             string
30242                         Colors           []color.NRGBA
30243                         CollideWithAOs   bool
30244                         StepHeight       float32
30245                         FaceRotateDir    bool
30246                         FaceRotateDirOff float32 // in degrees.
30247                         BackfaceCull     bool
30248                         Nametag          string
30249                         NametagColor     color.NRGBA
30250                         FaceRotateSpeed  float32 // in degrees per second.
30251                         Infotext         string
30252                         Itemstring       string
30253                         Glow             int8
30254                         MaxBreath        uint16  // Player only.
30255                         EyeHeight        float32 // Player only.
30256                         ZoomFOV          float32 // in degrees. Player only.
30257                         UseTextureAlpha  bool
30258                         DmgTextureMod    Texture // suffix
30259                         Shaded           bool
30260                         ShowOnMinimap    bool
30261                         NametagBG        color.NRGBA
30262                 }))(obj)).UseTextureAlpha
30263                 if x {
30264                         write8(w, 1)
30265                 } else {
30266                         write8(w, 0)
30267                 }
30268         }
30269         if err := pcall(func() {
30270                 ((*(*(struct {
30271                         MaxHP            uint16 // Player only.
30272                         CollideWithNodes bool
30273                         Weight           float32 // deprecated
30274                         ColBox, SelBox   Box
30275                         Pointable        bool
30276                         Visual           string
30277                         VisualSize       [3]float32
30278                         Textures         []Texture
30279                         SpriteSheetSize  [2]int16 // in sprites.
30280                         SpritePos        [2]int16 // in sprite sheet.
30281                         Visible          bool
30282                         MakeFootstepSnds bool
30283                         RotateSpeed      float32 // in radians per second.
30284                         Mesh             string
30285                         Colors           []color.NRGBA
30286                         CollideWithAOs   bool
30287                         StepHeight       float32
30288                         FaceRotateDir    bool
30289                         FaceRotateDirOff float32 // in degrees.
30290                         BackfaceCull     bool
30291                         Nametag          string
30292                         NametagColor     color.NRGBA
30293                         FaceRotateSpeed  float32 // in degrees per second.
30294                         Infotext         string
30295                         Itemstring       string
30296                         Glow             int8
30297                         MaxBreath        uint16  // Player only.
30298                         EyeHeight        float32 // Player only.
30299                         ZoomFOV          float32 // in degrees. Player only.
30300                         UseTextureAlpha  bool
30301                         DmgTextureMod    Texture // suffix
30302                         Shaded           bool
30303                         ShowOnMinimap    bool
30304                         NametagBG        color.NRGBA
30305                 }))(obj)).DmgTextureMod).serialize(w)
30306         }); err != nil {
30307                 if err == io.EOF {
30308                         chk(io.EOF)
30309                 }
30310                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
30311         }
30312         {
30313                 x := (*(*(struct {
30314                         MaxHP            uint16 // Player only.
30315                         CollideWithNodes bool
30316                         Weight           float32 // deprecated
30317                         ColBox, SelBox   Box
30318                         Pointable        bool
30319                         Visual           string
30320                         VisualSize       [3]float32
30321                         Textures         []Texture
30322                         SpriteSheetSize  [2]int16 // in sprites.
30323                         SpritePos        [2]int16 // in sprite sheet.
30324                         Visible          bool
30325                         MakeFootstepSnds bool
30326                         RotateSpeed      float32 // in radians per second.
30327                         Mesh             string
30328                         Colors           []color.NRGBA
30329                         CollideWithAOs   bool
30330                         StepHeight       float32
30331                         FaceRotateDir    bool
30332                         FaceRotateDirOff float32 // in degrees.
30333                         BackfaceCull     bool
30334                         Nametag          string
30335                         NametagColor     color.NRGBA
30336                         FaceRotateSpeed  float32 // in degrees per second.
30337                         Infotext         string
30338                         Itemstring       string
30339                         Glow             int8
30340                         MaxBreath        uint16  // Player only.
30341                         EyeHeight        float32 // Player only.
30342                         ZoomFOV          float32 // in degrees. Player only.
30343                         UseTextureAlpha  bool
30344                         DmgTextureMod    Texture // suffix
30345                         Shaded           bool
30346                         ShowOnMinimap    bool
30347                         NametagBG        color.NRGBA
30348                 }))(obj)).Shaded
30349                 if x {
30350                         write8(w, 1)
30351                 } else {
30352                         write8(w, 0)
30353                 }
30354         }
30355         {
30356                 x := (*(*(struct {
30357                         MaxHP            uint16 // Player only.
30358                         CollideWithNodes bool
30359                         Weight           float32 // deprecated
30360                         ColBox, SelBox   Box
30361                         Pointable        bool
30362                         Visual           string
30363                         VisualSize       [3]float32
30364                         Textures         []Texture
30365                         SpriteSheetSize  [2]int16 // in sprites.
30366                         SpritePos        [2]int16 // in sprite sheet.
30367                         Visible          bool
30368                         MakeFootstepSnds bool
30369                         RotateSpeed      float32 // in radians per second.
30370                         Mesh             string
30371                         Colors           []color.NRGBA
30372                         CollideWithAOs   bool
30373                         StepHeight       float32
30374                         FaceRotateDir    bool
30375                         FaceRotateDirOff float32 // in degrees.
30376                         BackfaceCull     bool
30377                         Nametag          string
30378                         NametagColor     color.NRGBA
30379                         FaceRotateSpeed  float32 // in degrees per second.
30380                         Infotext         string
30381                         Itemstring       string
30382                         Glow             int8
30383                         MaxBreath        uint16  // Player only.
30384                         EyeHeight        float32 // Player only.
30385                         ZoomFOV          float32 // in degrees. Player only.
30386                         UseTextureAlpha  bool
30387                         DmgTextureMod    Texture // suffix
30388                         Shaded           bool
30389                         ShowOnMinimap    bool
30390                         NametagBG        color.NRGBA
30391                 }))(obj)).ShowOnMinimap
30392                 if x {
30393                         write8(w, 1)
30394                 } else {
30395                         write8(w, 0)
30396                 }
30397         }
30398         {
30399                 x := (*(*(struct {
30400                         MaxHP            uint16 // Player only.
30401                         CollideWithNodes bool
30402                         Weight           float32 // deprecated
30403                         ColBox, SelBox   Box
30404                         Pointable        bool
30405                         Visual           string
30406                         VisualSize       [3]float32
30407                         Textures         []Texture
30408                         SpriteSheetSize  [2]int16 // in sprites.
30409                         SpritePos        [2]int16 // in sprite sheet.
30410                         Visible          bool
30411                         MakeFootstepSnds bool
30412                         RotateSpeed      float32 // in radians per second.
30413                         Mesh             string
30414                         Colors           []color.NRGBA
30415                         CollideWithAOs   bool
30416                         StepHeight       float32
30417                         FaceRotateDir    bool
30418                         FaceRotateDirOff float32 // in degrees.
30419                         BackfaceCull     bool
30420                         Nametag          string
30421                         NametagColor     color.NRGBA
30422                         FaceRotateSpeed  float32 // in degrees per second.
30423                         Infotext         string
30424                         Itemstring       string
30425                         Glow             int8
30426                         MaxBreath        uint16  // Player only.
30427                         EyeHeight        float32 // Player only.
30428                         ZoomFOV          float32 // in degrees. Player only.
30429                         UseTextureAlpha  bool
30430                         DmgTextureMod    Texture // suffix
30431                         Shaded           bool
30432                         ShowOnMinimap    bool
30433                         NametagBG        color.NRGBA
30434                 }))(obj)).NametagBG
30435                 w.Write([]byte{x.A, x.R, x.G, x.B})
30436         }
30437 }
30438
30439 func (obj *AOProps) deserialize(r io.Reader) {
30440         {
30441                 var local339 uint8
30442                 local340 := uint8(4)
30443                 {
30444                         p := &local339
30445                         *p = read8(r)
30446                 }
30447                 if local339 != local340 {
30448                         chk(fmt.Errorf("const %v: %v", "uint8(4)", local339))
30449                 }
30450         }
30451         {
30452                 p := &(*(*(struct {
30453                         MaxHP            uint16 // Player only.
30454                         CollideWithNodes bool
30455                         Weight           float32 // deprecated
30456                         ColBox, SelBox   Box
30457                         Pointable        bool
30458                         Visual           string
30459                         VisualSize       [3]float32
30460                         Textures         []Texture
30461                         SpriteSheetSize  [2]int16 // in sprites.
30462                         SpritePos        [2]int16 // in sprite sheet.
30463                         Visible          bool
30464                         MakeFootstepSnds bool
30465                         RotateSpeed      float32 // in radians per second.
30466                         Mesh             string
30467                         Colors           []color.NRGBA
30468                         CollideWithAOs   bool
30469                         StepHeight       float32
30470                         FaceRotateDir    bool
30471                         FaceRotateDirOff float32 // in degrees.
30472                         BackfaceCull     bool
30473                         Nametag          string
30474                         NametagColor     color.NRGBA
30475                         FaceRotateSpeed  float32 // in degrees per second.
30476                         Infotext         string
30477                         Itemstring       string
30478                         Glow             int8
30479                         MaxBreath        uint16  // Player only.
30480                         EyeHeight        float32 // Player only.
30481                         ZoomFOV          float32 // in degrees. Player only.
30482                         UseTextureAlpha  bool
30483                         DmgTextureMod    Texture // suffix
30484                         Shaded           bool
30485                         ShowOnMinimap    bool
30486                         NametagBG        color.NRGBA
30487                 }))(obj)).MaxHP
30488                 *p = read16(r)
30489         }
30490         {
30491                 p := &(*(*(struct {
30492                         MaxHP            uint16 // Player only.
30493                         CollideWithNodes bool
30494                         Weight           float32 // deprecated
30495                         ColBox, SelBox   Box
30496                         Pointable        bool
30497                         Visual           string
30498                         VisualSize       [3]float32
30499                         Textures         []Texture
30500                         SpriteSheetSize  [2]int16 // in sprites.
30501                         SpritePos        [2]int16 // in sprite sheet.
30502                         Visible          bool
30503                         MakeFootstepSnds bool
30504                         RotateSpeed      float32 // in radians per second.
30505                         Mesh             string
30506                         Colors           []color.NRGBA
30507                         CollideWithAOs   bool
30508                         StepHeight       float32
30509                         FaceRotateDir    bool
30510                         FaceRotateDirOff float32 // in degrees.
30511                         BackfaceCull     bool
30512                         Nametag          string
30513                         NametagColor     color.NRGBA
30514                         FaceRotateSpeed  float32 // in degrees per second.
30515                         Infotext         string
30516                         Itemstring       string
30517                         Glow             int8
30518                         MaxBreath        uint16  // Player only.
30519                         EyeHeight        float32 // Player only.
30520                         ZoomFOV          float32 // in degrees. Player only.
30521                         UseTextureAlpha  bool
30522                         DmgTextureMod    Texture // suffix
30523                         Shaded           bool
30524                         ShowOnMinimap    bool
30525                         NametagBG        color.NRGBA
30526                 }))(obj)).CollideWithNodes
30527                 switch n := read8(r); n {
30528                 case 0:
30529                         *p = false
30530                 case 1:
30531                         *p = true
30532                 default:
30533                         chk(fmt.Errorf("invalid bool: %d", n))
30534                 }
30535         }
30536         {
30537                 p := &(*(*(struct {
30538                         MaxHP            uint16 // Player only.
30539                         CollideWithNodes bool
30540                         Weight           float32 // deprecated
30541                         ColBox, SelBox   Box
30542                         Pointable        bool
30543                         Visual           string
30544                         VisualSize       [3]float32
30545                         Textures         []Texture
30546                         SpriteSheetSize  [2]int16 // in sprites.
30547                         SpritePos        [2]int16 // in sprite sheet.
30548                         Visible          bool
30549                         MakeFootstepSnds bool
30550                         RotateSpeed      float32 // in radians per second.
30551                         Mesh             string
30552                         Colors           []color.NRGBA
30553                         CollideWithAOs   bool
30554                         StepHeight       float32
30555                         FaceRotateDir    bool
30556                         FaceRotateDirOff float32 // in degrees.
30557                         BackfaceCull     bool
30558                         Nametag          string
30559                         NametagColor     color.NRGBA
30560                         FaceRotateSpeed  float32 // in degrees per second.
30561                         Infotext         string
30562                         Itemstring       string
30563                         Glow             int8
30564                         MaxBreath        uint16  // Player only.
30565                         EyeHeight        float32 // Player only.
30566                         ZoomFOV          float32 // in degrees. Player only.
30567                         UseTextureAlpha  bool
30568                         DmgTextureMod    Texture // suffix
30569                         Shaded           bool
30570                         ShowOnMinimap    bool
30571                         NametagBG        color.NRGBA
30572                 }))(obj)).Weight
30573                 *p = math.Float32frombits(read32(r))
30574         }
30575         if err := pcall(func() {
30576                 ((*(*(struct {
30577                         MaxHP            uint16 // Player only.
30578                         CollideWithNodes bool
30579                         Weight           float32 // deprecated
30580                         ColBox, SelBox   Box
30581                         Pointable        bool
30582                         Visual           string
30583                         VisualSize       [3]float32
30584                         Textures         []Texture
30585                         SpriteSheetSize  [2]int16 // in sprites.
30586                         SpritePos        [2]int16 // in sprite sheet.
30587                         Visible          bool
30588                         MakeFootstepSnds bool
30589                         RotateSpeed      float32 // in radians per second.
30590                         Mesh             string
30591                         Colors           []color.NRGBA
30592                         CollideWithAOs   bool
30593                         StepHeight       float32
30594                         FaceRotateDir    bool
30595                         FaceRotateDirOff float32 // in degrees.
30596                         BackfaceCull     bool
30597                         Nametag          string
30598                         NametagColor     color.NRGBA
30599                         FaceRotateSpeed  float32 // in degrees per second.
30600                         Infotext         string
30601                         Itemstring       string
30602                         Glow             int8
30603                         MaxBreath        uint16  // Player only.
30604                         EyeHeight        float32 // Player only.
30605                         ZoomFOV          float32 // in degrees. Player only.
30606                         UseTextureAlpha  bool
30607                         DmgTextureMod    Texture // suffix
30608                         Shaded           bool
30609                         ShowOnMinimap    bool
30610                         NametagBG        color.NRGBA
30611                 }))(obj)).ColBox).deserialize(r)
30612         }); err != nil {
30613                 if err == io.EOF {
30614                         chk(io.EOF)
30615                 }
30616                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
30617         }
30618         if err := pcall(func() {
30619                 ((*(*(struct {
30620                         MaxHP            uint16 // Player only.
30621                         CollideWithNodes bool
30622                         Weight           float32 // deprecated
30623                         ColBox, SelBox   Box
30624                         Pointable        bool
30625                         Visual           string
30626                         VisualSize       [3]float32
30627                         Textures         []Texture
30628                         SpriteSheetSize  [2]int16 // in sprites.
30629                         SpritePos        [2]int16 // in sprite sheet.
30630                         Visible          bool
30631                         MakeFootstepSnds bool
30632                         RotateSpeed      float32 // in radians per second.
30633                         Mesh             string
30634                         Colors           []color.NRGBA
30635                         CollideWithAOs   bool
30636                         StepHeight       float32
30637                         FaceRotateDir    bool
30638                         FaceRotateDirOff float32 // in degrees.
30639                         BackfaceCull     bool
30640                         Nametag          string
30641                         NametagColor     color.NRGBA
30642                         FaceRotateSpeed  float32 // in degrees per second.
30643                         Infotext         string
30644                         Itemstring       string
30645                         Glow             int8
30646                         MaxBreath        uint16  // Player only.
30647                         EyeHeight        float32 // Player only.
30648                         ZoomFOV          float32 // in degrees. Player only.
30649                         UseTextureAlpha  bool
30650                         DmgTextureMod    Texture // suffix
30651                         Shaded           bool
30652                         ShowOnMinimap    bool
30653                         NametagBG        color.NRGBA
30654                 }))(obj)).SelBox).deserialize(r)
30655         }); err != nil {
30656                 if err == io.EOF {
30657                         chk(io.EOF)
30658                 }
30659                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
30660         }
30661         {
30662                 p := &(*(*(struct {
30663                         MaxHP            uint16 // Player only.
30664                         CollideWithNodes bool
30665                         Weight           float32 // deprecated
30666                         ColBox, SelBox   Box
30667                         Pointable        bool
30668                         Visual           string
30669                         VisualSize       [3]float32
30670                         Textures         []Texture
30671                         SpriteSheetSize  [2]int16 // in sprites.
30672                         SpritePos        [2]int16 // in sprite sheet.
30673                         Visible          bool
30674                         MakeFootstepSnds bool
30675                         RotateSpeed      float32 // in radians per second.
30676                         Mesh             string
30677                         Colors           []color.NRGBA
30678                         CollideWithAOs   bool
30679                         StepHeight       float32
30680                         FaceRotateDir    bool
30681                         FaceRotateDirOff float32 // in degrees.
30682                         BackfaceCull     bool
30683                         Nametag          string
30684                         NametagColor     color.NRGBA
30685                         FaceRotateSpeed  float32 // in degrees per second.
30686                         Infotext         string
30687                         Itemstring       string
30688                         Glow             int8
30689                         MaxBreath        uint16  // Player only.
30690                         EyeHeight        float32 // Player only.
30691                         ZoomFOV          float32 // in degrees. Player only.
30692                         UseTextureAlpha  bool
30693                         DmgTextureMod    Texture // suffix
30694                         Shaded           bool
30695                         ShowOnMinimap    bool
30696                         NametagBG        color.NRGBA
30697                 }))(obj)).Pointable
30698                 switch n := read8(r); n {
30699                 case 0:
30700                         *p = false
30701                 case 1:
30702                         *p = true
30703                 default:
30704                         chk(fmt.Errorf("invalid bool: %d", n))
30705                 }
30706         }
30707         var local341 []uint8
30708         var local342 uint16
30709         {
30710                 p := &local342
30711                 *p = read16(r)
30712         }
30713         (local341) = make([]uint8, local342)
30714         {
30715                 _, err := io.ReadFull(r, (local341)[:])
30716                 chk(err)
30717         }
30718         ((*(*(struct {
30719                 MaxHP            uint16 // Player only.
30720                 CollideWithNodes bool
30721                 Weight           float32 // deprecated
30722                 ColBox, SelBox   Box
30723                 Pointable        bool
30724                 Visual           string
30725                 VisualSize       [3]float32
30726                 Textures         []Texture
30727                 SpriteSheetSize  [2]int16 // in sprites.
30728                 SpritePos        [2]int16 // in sprite sheet.
30729                 Visible          bool
30730                 MakeFootstepSnds bool
30731                 RotateSpeed      float32 // in radians per second.
30732                 Mesh             string
30733                 Colors           []color.NRGBA
30734                 CollideWithAOs   bool
30735                 StepHeight       float32
30736                 FaceRotateDir    bool
30737                 FaceRotateDirOff float32 // in degrees.
30738                 BackfaceCull     bool
30739                 Nametag          string
30740                 NametagColor     color.NRGBA
30741                 FaceRotateSpeed  float32 // in degrees per second.
30742                 Infotext         string
30743                 Itemstring       string
30744                 Glow             int8
30745                 MaxBreath        uint16  // Player only.
30746                 EyeHeight        float32 // Player only.
30747                 ZoomFOV          float32 // in degrees. Player only.
30748                 UseTextureAlpha  bool
30749                 DmgTextureMod    Texture // suffix
30750                 Shaded           bool
30751                 ShowOnMinimap    bool
30752                 NametagBG        color.NRGBA
30753         }))(obj)).Visual) = string(local341)
30754         for local343 := range (*(*(struct {
30755                 MaxHP            uint16 // Player only.
30756                 CollideWithNodes bool
30757                 Weight           float32 // deprecated
30758                 ColBox, SelBox   Box
30759                 Pointable        bool
30760                 Visual           string
30761                 VisualSize       [3]float32
30762                 Textures         []Texture
30763                 SpriteSheetSize  [2]int16 // in sprites.
30764                 SpritePos        [2]int16 // in sprite sheet.
30765                 Visible          bool
30766                 MakeFootstepSnds bool
30767                 RotateSpeed      float32 // in radians per second.
30768                 Mesh             string
30769                 Colors           []color.NRGBA
30770                 CollideWithAOs   bool
30771                 StepHeight       float32
30772                 FaceRotateDir    bool
30773                 FaceRotateDirOff float32 // in degrees.
30774                 BackfaceCull     bool
30775                 Nametag          string
30776                 NametagColor     color.NRGBA
30777                 FaceRotateSpeed  float32 // in degrees per second.
30778                 Infotext         string
30779                 Itemstring       string
30780                 Glow             int8
30781                 MaxBreath        uint16  // Player only.
30782                 EyeHeight        float32 // Player only.
30783                 ZoomFOV          float32 // in degrees. Player only.
30784                 UseTextureAlpha  bool
30785                 DmgTextureMod    Texture // suffix
30786                 Shaded           bool
30787                 ShowOnMinimap    bool
30788                 NametagBG        color.NRGBA
30789         }))(obj)).VisualSize {
30790                 {
30791                         p := &((*(*(struct {
30792                                 MaxHP            uint16 // Player only.
30793                                 CollideWithNodes bool
30794                                 Weight           float32 // deprecated
30795                                 ColBox, SelBox   Box
30796                                 Pointable        bool
30797                                 Visual           string
30798                                 VisualSize       [3]float32
30799                                 Textures         []Texture
30800                                 SpriteSheetSize  [2]int16 // in sprites.
30801                                 SpritePos        [2]int16 // in sprite sheet.
30802                                 Visible          bool
30803                                 MakeFootstepSnds bool
30804                                 RotateSpeed      float32 // in radians per second.
30805                                 Mesh             string
30806                                 Colors           []color.NRGBA
30807                                 CollideWithAOs   bool
30808                                 StepHeight       float32
30809                                 FaceRotateDir    bool
30810                                 FaceRotateDirOff float32 // in degrees.
30811                                 BackfaceCull     bool
30812                                 Nametag          string
30813                                 NametagColor     color.NRGBA
30814                                 FaceRotateSpeed  float32 // in degrees per second.
30815                                 Infotext         string
30816                                 Itemstring       string
30817                                 Glow             int8
30818                                 MaxBreath        uint16  // Player only.
30819                                 EyeHeight        float32 // Player only.
30820                                 ZoomFOV          float32 // in degrees. Player only.
30821                                 UseTextureAlpha  bool
30822                                 DmgTextureMod    Texture // suffix
30823                                 Shaded           bool
30824                                 ShowOnMinimap    bool
30825                                 NametagBG        color.NRGBA
30826                         }))(obj)).VisualSize)[local343]
30827                         *p = math.Float32frombits(read32(r))
30828                 }
30829         }
30830         var local344 uint16
30831         {
30832                 p := &local344
30833                 *p = read16(r)
30834         }
30835         ((*(*(struct {
30836                 MaxHP            uint16 // Player only.
30837                 CollideWithNodes bool
30838                 Weight           float32 // deprecated
30839                 ColBox, SelBox   Box
30840                 Pointable        bool
30841                 Visual           string
30842                 VisualSize       [3]float32
30843                 Textures         []Texture
30844                 SpriteSheetSize  [2]int16 // in sprites.
30845                 SpritePos        [2]int16 // in sprite sheet.
30846                 Visible          bool
30847                 MakeFootstepSnds bool
30848                 RotateSpeed      float32 // in radians per second.
30849                 Mesh             string
30850                 Colors           []color.NRGBA
30851                 CollideWithAOs   bool
30852                 StepHeight       float32
30853                 FaceRotateDir    bool
30854                 FaceRotateDirOff float32 // in degrees.
30855                 BackfaceCull     bool
30856                 Nametag          string
30857                 NametagColor     color.NRGBA
30858                 FaceRotateSpeed  float32 // in degrees per second.
30859                 Infotext         string
30860                 Itemstring       string
30861                 Glow             int8
30862                 MaxBreath        uint16  // Player only.
30863                 EyeHeight        float32 // Player only.
30864                 ZoomFOV          float32 // in degrees. Player only.
30865                 UseTextureAlpha  bool
30866                 DmgTextureMod    Texture // suffix
30867                 Shaded           bool
30868                 ShowOnMinimap    bool
30869                 NametagBG        color.NRGBA
30870         }))(obj)).Textures) = make([]Texture, local344)
30871         for local345 := range (*(*(struct {
30872                 MaxHP            uint16 // Player only.
30873                 CollideWithNodes bool
30874                 Weight           float32 // deprecated
30875                 ColBox, SelBox   Box
30876                 Pointable        bool
30877                 Visual           string
30878                 VisualSize       [3]float32
30879                 Textures         []Texture
30880                 SpriteSheetSize  [2]int16 // in sprites.
30881                 SpritePos        [2]int16 // in sprite sheet.
30882                 Visible          bool
30883                 MakeFootstepSnds bool
30884                 RotateSpeed      float32 // in radians per second.
30885                 Mesh             string
30886                 Colors           []color.NRGBA
30887                 CollideWithAOs   bool
30888                 StepHeight       float32
30889                 FaceRotateDir    bool
30890                 FaceRotateDirOff float32 // in degrees.
30891                 BackfaceCull     bool
30892                 Nametag          string
30893                 NametagColor     color.NRGBA
30894                 FaceRotateSpeed  float32 // in degrees per second.
30895                 Infotext         string
30896                 Itemstring       string
30897                 Glow             int8
30898                 MaxBreath        uint16  // Player only.
30899                 EyeHeight        float32 // Player only.
30900                 ZoomFOV          float32 // in degrees. Player only.
30901                 UseTextureAlpha  bool
30902                 DmgTextureMod    Texture // suffix
30903                 Shaded           bool
30904                 ShowOnMinimap    bool
30905                 NametagBG        color.NRGBA
30906         }))(obj)).Textures {
30907                 if err := pcall(func() {
30908                         (((*(*(struct {
30909                                 MaxHP            uint16 // Player only.
30910                                 CollideWithNodes bool
30911                                 Weight           float32 // deprecated
30912                                 ColBox, SelBox   Box
30913                                 Pointable        bool
30914                                 Visual           string
30915                                 VisualSize       [3]float32
30916                                 Textures         []Texture
30917                                 SpriteSheetSize  [2]int16 // in sprites.
30918                                 SpritePos        [2]int16 // in sprite sheet.
30919                                 Visible          bool
30920                                 MakeFootstepSnds bool
30921                                 RotateSpeed      float32 // in radians per second.
30922                                 Mesh             string
30923                                 Colors           []color.NRGBA
30924                                 CollideWithAOs   bool
30925                                 StepHeight       float32
30926                                 FaceRotateDir    bool
30927                                 FaceRotateDirOff float32 // in degrees.
30928                                 BackfaceCull     bool
30929                                 Nametag          string
30930                                 NametagColor     color.NRGBA
30931                                 FaceRotateSpeed  float32 // in degrees per second.
30932                                 Infotext         string
30933                                 Itemstring       string
30934                                 Glow             int8
30935                                 MaxBreath        uint16  // Player only.
30936                                 EyeHeight        float32 // Player only.
30937                                 ZoomFOV          float32 // in degrees. Player only.
30938                                 UseTextureAlpha  bool
30939                                 DmgTextureMod    Texture // suffix
30940                                 Shaded           bool
30941                                 ShowOnMinimap    bool
30942                                 NametagBG        color.NRGBA
30943                         }))(obj)).Textures)[local345]).deserialize(r)
30944                 }); err != nil {
30945                         if err == io.EOF {
30946                                 chk(io.EOF)
30947                         }
30948                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
30949                 }
30950         }
30951         for local346 := range (*(*(struct {
30952                 MaxHP            uint16 // Player only.
30953                 CollideWithNodes bool
30954                 Weight           float32 // deprecated
30955                 ColBox, SelBox   Box
30956                 Pointable        bool
30957                 Visual           string
30958                 VisualSize       [3]float32
30959                 Textures         []Texture
30960                 SpriteSheetSize  [2]int16 // in sprites.
30961                 SpritePos        [2]int16 // in sprite sheet.
30962                 Visible          bool
30963                 MakeFootstepSnds bool
30964                 RotateSpeed      float32 // in radians per second.
30965                 Mesh             string
30966                 Colors           []color.NRGBA
30967                 CollideWithAOs   bool
30968                 StepHeight       float32
30969                 FaceRotateDir    bool
30970                 FaceRotateDirOff float32 // in degrees.
30971                 BackfaceCull     bool
30972                 Nametag          string
30973                 NametagColor     color.NRGBA
30974                 FaceRotateSpeed  float32 // in degrees per second.
30975                 Infotext         string
30976                 Itemstring       string
30977                 Glow             int8
30978                 MaxBreath        uint16  // Player only.
30979                 EyeHeight        float32 // Player only.
30980                 ZoomFOV          float32 // in degrees. Player only.
30981                 UseTextureAlpha  bool
30982                 DmgTextureMod    Texture // suffix
30983                 Shaded           bool
30984                 ShowOnMinimap    bool
30985                 NametagBG        color.NRGBA
30986         }))(obj)).SpriteSheetSize {
30987                 {
30988                         p := &((*(*(struct {
30989                                 MaxHP            uint16 // Player only.
30990                                 CollideWithNodes bool
30991                                 Weight           float32 // deprecated
30992                                 ColBox, SelBox   Box
30993                                 Pointable        bool
30994                                 Visual           string
30995                                 VisualSize       [3]float32
30996                                 Textures         []Texture
30997                                 SpriteSheetSize  [2]int16 // in sprites.
30998                                 SpritePos        [2]int16 // in sprite sheet.
30999                                 Visible          bool
31000                                 MakeFootstepSnds bool
31001                                 RotateSpeed      float32 // in radians per second.
31002                                 Mesh             string
31003                                 Colors           []color.NRGBA
31004                                 CollideWithAOs   bool
31005                                 StepHeight       float32
31006                                 FaceRotateDir    bool
31007                                 FaceRotateDirOff float32 // in degrees.
31008                                 BackfaceCull     bool
31009                                 Nametag          string
31010                                 NametagColor     color.NRGBA
31011                                 FaceRotateSpeed  float32 // in degrees per second.
31012                                 Infotext         string
31013                                 Itemstring       string
31014                                 Glow             int8
31015                                 MaxBreath        uint16  // Player only.
31016                                 EyeHeight        float32 // Player only.
31017                                 ZoomFOV          float32 // in degrees. Player only.
31018                                 UseTextureAlpha  bool
31019                                 DmgTextureMod    Texture // suffix
31020                                 Shaded           bool
31021                                 ShowOnMinimap    bool
31022                                 NametagBG        color.NRGBA
31023                         }))(obj)).SpriteSheetSize)[local346]
31024                         *p = int16(read16(r))
31025                 }
31026         }
31027         for local347 := range (*(*(struct {
31028                 MaxHP            uint16 // Player only.
31029                 CollideWithNodes bool
31030                 Weight           float32 // deprecated
31031                 ColBox, SelBox   Box
31032                 Pointable        bool
31033                 Visual           string
31034                 VisualSize       [3]float32
31035                 Textures         []Texture
31036                 SpriteSheetSize  [2]int16 // in sprites.
31037                 SpritePos        [2]int16 // in sprite sheet.
31038                 Visible          bool
31039                 MakeFootstepSnds bool
31040                 RotateSpeed      float32 // in radians per second.
31041                 Mesh             string
31042                 Colors           []color.NRGBA
31043                 CollideWithAOs   bool
31044                 StepHeight       float32
31045                 FaceRotateDir    bool
31046                 FaceRotateDirOff float32 // in degrees.
31047                 BackfaceCull     bool
31048                 Nametag          string
31049                 NametagColor     color.NRGBA
31050                 FaceRotateSpeed  float32 // in degrees per second.
31051                 Infotext         string
31052                 Itemstring       string
31053                 Glow             int8
31054                 MaxBreath        uint16  // Player only.
31055                 EyeHeight        float32 // Player only.
31056                 ZoomFOV          float32 // in degrees. Player only.
31057                 UseTextureAlpha  bool
31058                 DmgTextureMod    Texture // suffix
31059                 Shaded           bool
31060                 ShowOnMinimap    bool
31061                 NametagBG        color.NRGBA
31062         }))(obj)).SpritePos {
31063                 {
31064                         p := &((*(*(struct {
31065                                 MaxHP            uint16 // Player only.
31066                                 CollideWithNodes bool
31067                                 Weight           float32 // deprecated
31068                                 ColBox, SelBox   Box
31069                                 Pointable        bool
31070                                 Visual           string
31071                                 VisualSize       [3]float32
31072                                 Textures         []Texture
31073                                 SpriteSheetSize  [2]int16 // in sprites.
31074                                 SpritePos        [2]int16 // in sprite sheet.
31075                                 Visible          bool
31076                                 MakeFootstepSnds bool
31077                                 RotateSpeed      float32 // in radians per second.
31078                                 Mesh             string
31079                                 Colors           []color.NRGBA
31080                                 CollideWithAOs   bool
31081                                 StepHeight       float32
31082                                 FaceRotateDir    bool
31083                                 FaceRotateDirOff float32 // in degrees.
31084                                 BackfaceCull     bool
31085                                 Nametag          string
31086                                 NametagColor     color.NRGBA
31087                                 FaceRotateSpeed  float32 // in degrees per second.
31088                                 Infotext         string
31089                                 Itemstring       string
31090                                 Glow             int8
31091                                 MaxBreath        uint16  // Player only.
31092                                 EyeHeight        float32 // Player only.
31093                                 ZoomFOV          float32 // in degrees. Player only.
31094                                 UseTextureAlpha  bool
31095                                 DmgTextureMod    Texture // suffix
31096                                 Shaded           bool
31097                                 ShowOnMinimap    bool
31098                                 NametagBG        color.NRGBA
31099                         }))(obj)).SpritePos)[local347]
31100                         *p = int16(read16(r))
31101                 }
31102         }
31103         {
31104                 p := &(*(*(struct {
31105                         MaxHP            uint16 // Player only.
31106                         CollideWithNodes bool
31107                         Weight           float32 // deprecated
31108                         ColBox, SelBox   Box
31109                         Pointable        bool
31110                         Visual           string
31111                         VisualSize       [3]float32
31112                         Textures         []Texture
31113                         SpriteSheetSize  [2]int16 // in sprites.
31114                         SpritePos        [2]int16 // in sprite sheet.
31115                         Visible          bool
31116                         MakeFootstepSnds bool
31117                         RotateSpeed      float32 // in radians per second.
31118                         Mesh             string
31119                         Colors           []color.NRGBA
31120                         CollideWithAOs   bool
31121                         StepHeight       float32
31122                         FaceRotateDir    bool
31123                         FaceRotateDirOff float32 // in degrees.
31124                         BackfaceCull     bool
31125                         Nametag          string
31126                         NametagColor     color.NRGBA
31127                         FaceRotateSpeed  float32 // in degrees per second.
31128                         Infotext         string
31129                         Itemstring       string
31130                         Glow             int8
31131                         MaxBreath        uint16  // Player only.
31132                         EyeHeight        float32 // Player only.
31133                         ZoomFOV          float32 // in degrees. Player only.
31134                         UseTextureAlpha  bool
31135                         DmgTextureMod    Texture // suffix
31136                         Shaded           bool
31137                         ShowOnMinimap    bool
31138                         NametagBG        color.NRGBA
31139                 }))(obj)).Visible
31140                 switch n := read8(r); n {
31141                 case 0:
31142                         *p = false
31143                 case 1:
31144                         *p = true
31145                 default:
31146                         chk(fmt.Errorf("invalid bool: %d", n))
31147                 }
31148         }
31149         {
31150                 p := &(*(*(struct {
31151                         MaxHP            uint16 // Player only.
31152                         CollideWithNodes bool
31153                         Weight           float32 // deprecated
31154                         ColBox, SelBox   Box
31155                         Pointable        bool
31156                         Visual           string
31157                         VisualSize       [3]float32
31158                         Textures         []Texture
31159                         SpriteSheetSize  [2]int16 // in sprites.
31160                         SpritePos        [2]int16 // in sprite sheet.
31161                         Visible          bool
31162                         MakeFootstepSnds bool
31163                         RotateSpeed      float32 // in radians per second.
31164                         Mesh             string
31165                         Colors           []color.NRGBA
31166                         CollideWithAOs   bool
31167                         StepHeight       float32
31168                         FaceRotateDir    bool
31169                         FaceRotateDirOff float32 // in degrees.
31170                         BackfaceCull     bool
31171                         Nametag          string
31172                         NametagColor     color.NRGBA
31173                         FaceRotateSpeed  float32 // in degrees per second.
31174                         Infotext         string
31175                         Itemstring       string
31176                         Glow             int8
31177                         MaxBreath        uint16  // Player only.
31178                         EyeHeight        float32 // Player only.
31179                         ZoomFOV          float32 // in degrees. Player only.
31180                         UseTextureAlpha  bool
31181                         DmgTextureMod    Texture // suffix
31182                         Shaded           bool
31183                         ShowOnMinimap    bool
31184                         NametagBG        color.NRGBA
31185                 }))(obj)).MakeFootstepSnds
31186                 switch n := read8(r); n {
31187                 case 0:
31188                         *p = false
31189                 case 1:
31190                         *p = true
31191                 default:
31192                         chk(fmt.Errorf("invalid bool: %d", n))
31193                 }
31194         }
31195         {
31196                 p := &(*(*(struct {
31197                         MaxHP            uint16 // Player only.
31198                         CollideWithNodes bool
31199                         Weight           float32 // deprecated
31200                         ColBox, SelBox   Box
31201                         Pointable        bool
31202                         Visual           string
31203                         VisualSize       [3]float32
31204                         Textures         []Texture
31205                         SpriteSheetSize  [2]int16 // in sprites.
31206                         SpritePos        [2]int16 // in sprite sheet.
31207                         Visible          bool
31208                         MakeFootstepSnds bool
31209                         RotateSpeed      float32 // in radians per second.
31210                         Mesh             string
31211                         Colors           []color.NRGBA
31212                         CollideWithAOs   bool
31213                         StepHeight       float32
31214                         FaceRotateDir    bool
31215                         FaceRotateDirOff float32 // in degrees.
31216                         BackfaceCull     bool
31217                         Nametag          string
31218                         NametagColor     color.NRGBA
31219                         FaceRotateSpeed  float32 // in degrees per second.
31220                         Infotext         string
31221                         Itemstring       string
31222                         Glow             int8
31223                         MaxBreath        uint16  // Player only.
31224                         EyeHeight        float32 // Player only.
31225                         ZoomFOV          float32 // in degrees. Player only.
31226                         UseTextureAlpha  bool
31227                         DmgTextureMod    Texture // suffix
31228                         Shaded           bool
31229                         ShowOnMinimap    bool
31230                         NametagBG        color.NRGBA
31231                 }))(obj)).RotateSpeed
31232                 *p = math.Float32frombits(read32(r))
31233         }
31234         var local348 []uint8
31235         var local349 uint16
31236         {
31237                 p := &local349
31238                 *p = read16(r)
31239         }
31240         (local348) = make([]uint8, local349)
31241         {
31242                 _, err := io.ReadFull(r, (local348)[:])
31243                 chk(err)
31244         }
31245         ((*(*(struct {
31246                 MaxHP            uint16 // Player only.
31247                 CollideWithNodes bool
31248                 Weight           float32 // deprecated
31249                 ColBox, SelBox   Box
31250                 Pointable        bool
31251                 Visual           string
31252                 VisualSize       [3]float32
31253                 Textures         []Texture
31254                 SpriteSheetSize  [2]int16 // in sprites.
31255                 SpritePos        [2]int16 // in sprite sheet.
31256                 Visible          bool
31257                 MakeFootstepSnds bool
31258                 RotateSpeed      float32 // in radians per second.
31259                 Mesh             string
31260                 Colors           []color.NRGBA
31261                 CollideWithAOs   bool
31262                 StepHeight       float32
31263                 FaceRotateDir    bool
31264                 FaceRotateDirOff float32 // in degrees.
31265                 BackfaceCull     bool
31266                 Nametag          string
31267                 NametagColor     color.NRGBA
31268                 FaceRotateSpeed  float32 // in degrees per second.
31269                 Infotext         string
31270                 Itemstring       string
31271                 Glow             int8
31272                 MaxBreath        uint16  // Player only.
31273                 EyeHeight        float32 // Player only.
31274                 ZoomFOV          float32 // in degrees. Player only.
31275                 UseTextureAlpha  bool
31276                 DmgTextureMod    Texture // suffix
31277                 Shaded           bool
31278                 ShowOnMinimap    bool
31279                 NametagBG        color.NRGBA
31280         }))(obj)).Mesh) = string(local348)
31281         var local350 uint16
31282         {
31283                 p := &local350
31284                 *p = read16(r)
31285         }
31286         ((*(*(struct {
31287                 MaxHP            uint16 // Player only.
31288                 CollideWithNodes bool
31289                 Weight           float32 // deprecated
31290                 ColBox, SelBox   Box
31291                 Pointable        bool
31292                 Visual           string
31293                 VisualSize       [3]float32
31294                 Textures         []Texture
31295                 SpriteSheetSize  [2]int16 // in sprites.
31296                 SpritePos        [2]int16 // in sprite sheet.
31297                 Visible          bool
31298                 MakeFootstepSnds bool
31299                 RotateSpeed      float32 // in radians per second.
31300                 Mesh             string
31301                 Colors           []color.NRGBA
31302                 CollideWithAOs   bool
31303                 StepHeight       float32
31304                 FaceRotateDir    bool
31305                 FaceRotateDirOff float32 // in degrees.
31306                 BackfaceCull     bool
31307                 Nametag          string
31308                 NametagColor     color.NRGBA
31309                 FaceRotateSpeed  float32 // in degrees per second.
31310                 Infotext         string
31311                 Itemstring       string
31312                 Glow             int8
31313                 MaxBreath        uint16  // Player only.
31314                 EyeHeight        float32 // Player only.
31315                 ZoomFOV          float32 // in degrees. Player only.
31316                 UseTextureAlpha  bool
31317                 DmgTextureMod    Texture // suffix
31318                 Shaded           bool
31319                 ShowOnMinimap    bool
31320                 NametagBG        color.NRGBA
31321         }))(obj)).Colors) = make([]color.NRGBA, local350)
31322         for local351 := range (*(*(struct {
31323                 MaxHP            uint16 // Player only.
31324                 CollideWithNodes bool
31325                 Weight           float32 // deprecated
31326                 ColBox, SelBox   Box
31327                 Pointable        bool
31328                 Visual           string
31329                 VisualSize       [3]float32
31330                 Textures         []Texture
31331                 SpriteSheetSize  [2]int16 // in sprites.
31332                 SpritePos        [2]int16 // in sprite sheet.
31333                 Visible          bool
31334                 MakeFootstepSnds bool
31335                 RotateSpeed      float32 // in radians per second.
31336                 Mesh             string
31337                 Colors           []color.NRGBA
31338                 CollideWithAOs   bool
31339                 StepHeight       float32
31340                 FaceRotateDir    bool
31341                 FaceRotateDirOff float32 // in degrees.
31342                 BackfaceCull     bool
31343                 Nametag          string
31344                 NametagColor     color.NRGBA
31345                 FaceRotateSpeed  float32 // in degrees per second.
31346                 Infotext         string
31347                 Itemstring       string
31348                 Glow             int8
31349                 MaxBreath        uint16  // Player only.
31350                 EyeHeight        float32 // Player only.
31351                 ZoomFOV          float32 // in degrees. Player only.
31352                 UseTextureAlpha  bool
31353                 DmgTextureMod    Texture // suffix
31354                 Shaded           bool
31355                 ShowOnMinimap    bool
31356                 NametagBG        color.NRGBA
31357         }))(obj)).Colors {
31358                 {
31359                         p := &((*(*(struct {
31360                                 MaxHP            uint16 // Player only.
31361                                 CollideWithNodes bool
31362                                 Weight           float32 // deprecated
31363                                 ColBox, SelBox   Box
31364                                 Pointable        bool
31365                                 Visual           string
31366                                 VisualSize       [3]float32
31367                                 Textures         []Texture
31368                                 SpriteSheetSize  [2]int16 // in sprites.
31369                                 SpritePos        [2]int16 // in sprite sheet.
31370                                 Visible          bool
31371                                 MakeFootstepSnds bool
31372                                 RotateSpeed      float32 // in radians per second.
31373                                 Mesh             string
31374                                 Colors           []color.NRGBA
31375                                 CollideWithAOs   bool
31376                                 StepHeight       float32
31377                                 FaceRotateDir    bool
31378                                 FaceRotateDirOff float32 // in degrees.
31379                                 BackfaceCull     bool
31380                                 Nametag          string
31381                                 NametagColor     color.NRGBA
31382                                 FaceRotateSpeed  float32 // in degrees per second.
31383                                 Infotext         string
31384                                 Itemstring       string
31385                                 Glow             int8
31386                                 MaxBreath        uint16  // Player only.
31387                                 EyeHeight        float32 // Player only.
31388                                 ZoomFOV          float32 // in degrees. Player only.
31389                                 UseTextureAlpha  bool
31390                                 DmgTextureMod    Texture // suffix
31391                                 Shaded           bool
31392                                 ShowOnMinimap    bool
31393                                 NametagBG        color.NRGBA
31394                         }))(obj)).Colors)[local351]
31395                         *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31396                 }
31397         }
31398         {
31399                 p := &(*(*(struct {
31400                         MaxHP            uint16 // Player only.
31401                         CollideWithNodes bool
31402                         Weight           float32 // deprecated
31403                         ColBox, SelBox   Box
31404                         Pointable        bool
31405                         Visual           string
31406                         VisualSize       [3]float32
31407                         Textures         []Texture
31408                         SpriteSheetSize  [2]int16 // in sprites.
31409                         SpritePos        [2]int16 // in sprite sheet.
31410                         Visible          bool
31411                         MakeFootstepSnds bool
31412                         RotateSpeed      float32 // in radians per second.
31413                         Mesh             string
31414                         Colors           []color.NRGBA
31415                         CollideWithAOs   bool
31416                         StepHeight       float32
31417                         FaceRotateDir    bool
31418                         FaceRotateDirOff float32 // in degrees.
31419                         BackfaceCull     bool
31420                         Nametag          string
31421                         NametagColor     color.NRGBA
31422                         FaceRotateSpeed  float32 // in degrees per second.
31423                         Infotext         string
31424                         Itemstring       string
31425                         Glow             int8
31426                         MaxBreath        uint16  // Player only.
31427                         EyeHeight        float32 // Player only.
31428                         ZoomFOV          float32 // in degrees. Player only.
31429                         UseTextureAlpha  bool
31430                         DmgTextureMod    Texture // suffix
31431                         Shaded           bool
31432                         ShowOnMinimap    bool
31433                         NametagBG        color.NRGBA
31434                 }))(obj)).CollideWithAOs
31435                 switch n := read8(r); n {
31436                 case 0:
31437                         *p = false
31438                 case 1:
31439                         *p = true
31440                 default:
31441                         chk(fmt.Errorf("invalid bool: %d", n))
31442                 }
31443         }
31444         {
31445                 p := &(*(*(struct {
31446                         MaxHP            uint16 // Player only.
31447                         CollideWithNodes bool
31448                         Weight           float32 // deprecated
31449                         ColBox, SelBox   Box
31450                         Pointable        bool
31451                         Visual           string
31452                         VisualSize       [3]float32
31453                         Textures         []Texture
31454                         SpriteSheetSize  [2]int16 // in sprites.
31455                         SpritePos        [2]int16 // in sprite sheet.
31456                         Visible          bool
31457                         MakeFootstepSnds bool
31458                         RotateSpeed      float32 // in radians per second.
31459                         Mesh             string
31460                         Colors           []color.NRGBA
31461                         CollideWithAOs   bool
31462                         StepHeight       float32
31463                         FaceRotateDir    bool
31464                         FaceRotateDirOff float32 // in degrees.
31465                         BackfaceCull     bool
31466                         Nametag          string
31467                         NametagColor     color.NRGBA
31468                         FaceRotateSpeed  float32 // in degrees per second.
31469                         Infotext         string
31470                         Itemstring       string
31471                         Glow             int8
31472                         MaxBreath        uint16  // Player only.
31473                         EyeHeight        float32 // Player only.
31474                         ZoomFOV          float32 // in degrees. Player only.
31475                         UseTextureAlpha  bool
31476                         DmgTextureMod    Texture // suffix
31477                         Shaded           bool
31478                         ShowOnMinimap    bool
31479                         NametagBG        color.NRGBA
31480                 }))(obj)).StepHeight
31481                 *p = math.Float32frombits(read32(r))
31482         }
31483         {
31484                 p := &(*(*(struct {
31485                         MaxHP            uint16 // Player only.
31486                         CollideWithNodes bool
31487                         Weight           float32 // deprecated
31488                         ColBox, SelBox   Box
31489                         Pointable        bool
31490                         Visual           string
31491                         VisualSize       [3]float32
31492                         Textures         []Texture
31493                         SpriteSheetSize  [2]int16 // in sprites.
31494                         SpritePos        [2]int16 // in sprite sheet.
31495                         Visible          bool
31496                         MakeFootstepSnds bool
31497                         RotateSpeed      float32 // in radians per second.
31498                         Mesh             string
31499                         Colors           []color.NRGBA
31500                         CollideWithAOs   bool
31501                         StepHeight       float32
31502                         FaceRotateDir    bool
31503                         FaceRotateDirOff float32 // in degrees.
31504                         BackfaceCull     bool
31505                         Nametag          string
31506                         NametagColor     color.NRGBA
31507                         FaceRotateSpeed  float32 // in degrees per second.
31508                         Infotext         string
31509                         Itemstring       string
31510                         Glow             int8
31511                         MaxBreath        uint16  // Player only.
31512                         EyeHeight        float32 // Player only.
31513                         ZoomFOV          float32 // in degrees. Player only.
31514                         UseTextureAlpha  bool
31515                         DmgTextureMod    Texture // suffix
31516                         Shaded           bool
31517                         ShowOnMinimap    bool
31518                         NametagBG        color.NRGBA
31519                 }))(obj)).FaceRotateDir
31520                 switch n := read8(r); n {
31521                 case 0:
31522                         *p = false
31523                 case 1:
31524                         *p = true
31525                 default:
31526                         chk(fmt.Errorf("invalid bool: %d", n))
31527                 }
31528         }
31529         {
31530                 p := &(*(*(struct {
31531                         MaxHP            uint16 // Player only.
31532                         CollideWithNodes bool
31533                         Weight           float32 // deprecated
31534                         ColBox, SelBox   Box
31535                         Pointable        bool
31536                         Visual           string
31537                         VisualSize       [3]float32
31538                         Textures         []Texture
31539                         SpriteSheetSize  [2]int16 // in sprites.
31540                         SpritePos        [2]int16 // in sprite sheet.
31541                         Visible          bool
31542                         MakeFootstepSnds bool
31543                         RotateSpeed      float32 // in radians per second.
31544                         Mesh             string
31545                         Colors           []color.NRGBA
31546                         CollideWithAOs   bool
31547                         StepHeight       float32
31548                         FaceRotateDir    bool
31549                         FaceRotateDirOff float32 // in degrees.
31550                         BackfaceCull     bool
31551                         Nametag          string
31552                         NametagColor     color.NRGBA
31553                         FaceRotateSpeed  float32 // in degrees per second.
31554                         Infotext         string
31555                         Itemstring       string
31556                         Glow             int8
31557                         MaxBreath        uint16  // Player only.
31558                         EyeHeight        float32 // Player only.
31559                         ZoomFOV          float32 // in degrees. Player only.
31560                         UseTextureAlpha  bool
31561                         DmgTextureMod    Texture // suffix
31562                         Shaded           bool
31563                         ShowOnMinimap    bool
31564                         NametagBG        color.NRGBA
31565                 }))(obj)).FaceRotateDirOff
31566                 *p = math.Float32frombits(read32(r))
31567         }
31568         {
31569                 p := &(*(*(struct {
31570                         MaxHP            uint16 // Player only.
31571                         CollideWithNodes bool
31572                         Weight           float32 // deprecated
31573                         ColBox, SelBox   Box
31574                         Pointable        bool
31575                         Visual           string
31576                         VisualSize       [3]float32
31577                         Textures         []Texture
31578                         SpriteSheetSize  [2]int16 // in sprites.
31579                         SpritePos        [2]int16 // in sprite sheet.
31580                         Visible          bool
31581                         MakeFootstepSnds bool
31582                         RotateSpeed      float32 // in radians per second.
31583                         Mesh             string
31584                         Colors           []color.NRGBA
31585                         CollideWithAOs   bool
31586                         StepHeight       float32
31587                         FaceRotateDir    bool
31588                         FaceRotateDirOff float32 // in degrees.
31589                         BackfaceCull     bool
31590                         Nametag          string
31591                         NametagColor     color.NRGBA
31592                         FaceRotateSpeed  float32 // in degrees per second.
31593                         Infotext         string
31594                         Itemstring       string
31595                         Glow             int8
31596                         MaxBreath        uint16  // Player only.
31597                         EyeHeight        float32 // Player only.
31598                         ZoomFOV          float32 // in degrees. Player only.
31599                         UseTextureAlpha  bool
31600                         DmgTextureMod    Texture // suffix
31601                         Shaded           bool
31602                         ShowOnMinimap    bool
31603                         NametagBG        color.NRGBA
31604                 }))(obj)).BackfaceCull
31605                 switch n := read8(r); n {
31606                 case 0:
31607                         *p = false
31608                 case 1:
31609                         *p = true
31610                 default:
31611                         chk(fmt.Errorf("invalid bool: %d", n))
31612                 }
31613         }
31614         var local352 []uint8
31615         var local353 uint16
31616         {
31617                 p := &local353
31618                 *p = read16(r)
31619         }
31620         (local352) = make([]uint8, local353)
31621         {
31622                 _, err := io.ReadFull(r, (local352)[:])
31623                 chk(err)
31624         }
31625         ((*(*(struct {
31626                 MaxHP            uint16 // Player only.
31627                 CollideWithNodes bool
31628                 Weight           float32 // deprecated
31629                 ColBox, SelBox   Box
31630                 Pointable        bool
31631                 Visual           string
31632                 VisualSize       [3]float32
31633                 Textures         []Texture
31634                 SpriteSheetSize  [2]int16 // in sprites.
31635                 SpritePos        [2]int16 // in sprite sheet.
31636                 Visible          bool
31637                 MakeFootstepSnds bool
31638                 RotateSpeed      float32 // in radians per second.
31639                 Mesh             string
31640                 Colors           []color.NRGBA
31641                 CollideWithAOs   bool
31642                 StepHeight       float32
31643                 FaceRotateDir    bool
31644                 FaceRotateDirOff float32 // in degrees.
31645                 BackfaceCull     bool
31646                 Nametag          string
31647                 NametagColor     color.NRGBA
31648                 FaceRotateSpeed  float32 // in degrees per second.
31649                 Infotext         string
31650                 Itemstring       string
31651                 Glow             int8
31652                 MaxBreath        uint16  // Player only.
31653                 EyeHeight        float32 // Player only.
31654                 ZoomFOV          float32 // in degrees. Player only.
31655                 UseTextureAlpha  bool
31656                 DmgTextureMod    Texture // suffix
31657                 Shaded           bool
31658                 ShowOnMinimap    bool
31659                 NametagBG        color.NRGBA
31660         }))(obj)).Nametag) = string(local352)
31661         {
31662                 p := &(*(*(struct {
31663                         MaxHP            uint16 // Player only.
31664                         CollideWithNodes bool
31665                         Weight           float32 // deprecated
31666                         ColBox, SelBox   Box
31667                         Pointable        bool
31668                         Visual           string
31669                         VisualSize       [3]float32
31670                         Textures         []Texture
31671                         SpriteSheetSize  [2]int16 // in sprites.
31672                         SpritePos        [2]int16 // in sprite sheet.
31673                         Visible          bool
31674                         MakeFootstepSnds bool
31675                         RotateSpeed      float32 // in radians per second.
31676                         Mesh             string
31677                         Colors           []color.NRGBA
31678                         CollideWithAOs   bool
31679                         StepHeight       float32
31680                         FaceRotateDir    bool
31681                         FaceRotateDirOff float32 // in degrees.
31682                         BackfaceCull     bool
31683                         Nametag          string
31684                         NametagColor     color.NRGBA
31685                         FaceRotateSpeed  float32 // in degrees per second.
31686                         Infotext         string
31687                         Itemstring       string
31688                         Glow             int8
31689                         MaxBreath        uint16  // Player only.
31690                         EyeHeight        float32 // Player only.
31691                         ZoomFOV          float32 // in degrees. Player only.
31692                         UseTextureAlpha  bool
31693                         DmgTextureMod    Texture // suffix
31694                         Shaded           bool
31695                         ShowOnMinimap    bool
31696                         NametagBG        color.NRGBA
31697                 }))(obj)).NametagColor
31698                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
31699         }
31700         {
31701                 p := &(*(*(struct {
31702                         MaxHP            uint16 // Player only.
31703                         CollideWithNodes bool
31704                         Weight           float32 // deprecated
31705                         ColBox, SelBox   Box
31706                         Pointable        bool
31707                         Visual           string
31708                         VisualSize       [3]float32
31709                         Textures         []Texture
31710                         SpriteSheetSize  [2]int16 // in sprites.
31711                         SpritePos        [2]int16 // in sprite sheet.
31712                         Visible          bool
31713                         MakeFootstepSnds bool
31714                         RotateSpeed      float32 // in radians per second.
31715                         Mesh             string
31716                         Colors           []color.NRGBA
31717                         CollideWithAOs   bool
31718                         StepHeight       float32
31719                         FaceRotateDir    bool
31720                         FaceRotateDirOff float32 // in degrees.
31721                         BackfaceCull     bool
31722                         Nametag          string
31723                         NametagColor     color.NRGBA
31724                         FaceRotateSpeed  float32 // in degrees per second.
31725                         Infotext         string
31726                         Itemstring       string
31727                         Glow             int8
31728                         MaxBreath        uint16  // Player only.
31729                         EyeHeight        float32 // Player only.
31730                         ZoomFOV          float32 // in degrees. Player only.
31731                         UseTextureAlpha  bool
31732                         DmgTextureMod    Texture // suffix
31733                         Shaded           bool
31734                         ShowOnMinimap    bool
31735                         NametagBG        color.NRGBA
31736                 }))(obj)).FaceRotateSpeed
31737                 *p = math.Float32frombits(read32(r))
31738         }
31739         var local354 []uint8
31740         var local355 uint16
31741         {
31742                 p := &local355
31743                 *p = read16(r)
31744         }
31745         (local354) = make([]uint8, local355)
31746         {
31747                 _, err := io.ReadFull(r, (local354)[:])
31748                 chk(err)
31749         }
31750         ((*(*(struct {
31751                 MaxHP            uint16 // Player only.
31752                 CollideWithNodes bool
31753                 Weight           float32 // deprecated
31754                 ColBox, SelBox   Box
31755                 Pointable        bool
31756                 Visual           string
31757                 VisualSize       [3]float32
31758                 Textures         []Texture
31759                 SpriteSheetSize  [2]int16 // in sprites.
31760                 SpritePos        [2]int16 // in sprite sheet.
31761                 Visible          bool
31762                 MakeFootstepSnds bool
31763                 RotateSpeed      float32 // in radians per second.
31764                 Mesh             string
31765                 Colors           []color.NRGBA
31766                 CollideWithAOs   bool
31767                 StepHeight       float32
31768                 FaceRotateDir    bool
31769                 FaceRotateDirOff float32 // in degrees.
31770                 BackfaceCull     bool
31771                 Nametag          string
31772                 NametagColor     color.NRGBA
31773                 FaceRotateSpeed  float32 // in degrees per second.
31774                 Infotext         string
31775                 Itemstring       string
31776                 Glow             int8
31777                 MaxBreath        uint16  // Player only.
31778                 EyeHeight        float32 // Player only.
31779                 ZoomFOV          float32 // in degrees. Player only.
31780                 UseTextureAlpha  bool
31781                 DmgTextureMod    Texture // suffix
31782                 Shaded           bool
31783                 ShowOnMinimap    bool
31784                 NametagBG        color.NRGBA
31785         }))(obj)).Infotext) = string(local354)
31786         var local356 []uint8
31787         var local357 uint16
31788         {
31789                 p := &local357
31790                 *p = read16(r)
31791         }
31792         (local356) = make([]uint8, local357)
31793         {
31794                 _, err := io.ReadFull(r, (local356)[:])
31795                 chk(err)
31796         }
31797         ((*(*(struct {
31798                 MaxHP            uint16 // Player only.
31799                 CollideWithNodes bool
31800                 Weight           float32 // deprecated
31801                 ColBox, SelBox   Box
31802                 Pointable        bool
31803                 Visual           string
31804                 VisualSize       [3]float32
31805                 Textures         []Texture
31806                 SpriteSheetSize  [2]int16 // in sprites.
31807                 SpritePos        [2]int16 // in sprite sheet.
31808                 Visible          bool
31809                 MakeFootstepSnds bool
31810                 RotateSpeed      float32 // in radians per second.
31811                 Mesh             string
31812                 Colors           []color.NRGBA
31813                 CollideWithAOs   bool
31814                 StepHeight       float32
31815                 FaceRotateDir    bool
31816                 FaceRotateDirOff float32 // in degrees.
31817                 BackfaceCull     bool
31818                 Nametag          string
31819                 NametagColor     color.NRGBA
31820                 FaceRotateSpeed  float32 // in degrees per second.
31821                 Infotext         string
31822                 Itemstring       string
31823                 Glow             int8
31824                 MaxBreath        uint16  // Player only.
31825                 EyeHeight        float32 // Player only.
31826                 ZoomFOV          float32 // in degrees. Player only.
31827                 UseTextureAlpha  bool
31828                 DmgTextureMod    Texture // suffix
31829                 Shaded           bool
31830                 ShowOnMinimap    bool
31831                 NametagBG        color.NRGBA
31832         }))(obj)).Itemstring) = string(local356)
31833         {
31834                 p := &(*(*(struct {
31835                         MaxHP            uint16 // Player only.
31836                         CollideWithNodes bool
31837                         Weight           float32 // deprecated
31838                         ColBox, SelBox   Box
31839                         Pointable        bool
31840                         Visual           string
31841                         VisualSize       [3]float32
31842                         Textures         []Texture
31843                         SpriteSheetSize  [2]int16 // in sprites.
31844                         SpritePos        [2]int16 // in sprite sheet.
31845                         Visible          bool
31846                         MakeFootstepSnds bool
31847                         RotateSpeed      float32 // in radians per second.
31848                         Mesh             string
31849                         Colors           []color.NRGBA
31850                         CollideWithAOs   bool
31851                         StepHeight       float32
31852                         FaceRotateDir    bool
31853                         FaceRotateDirOff float32 // in degrees.
31854                         BackfaceCull     bool
31855                         Nametag          string
31856                         NametagColor     color.NRGBA
31857                         FaceRotateSpeed  float32 // in degrees per second.
31858                         Infotext         string
31859                         Itemstring       string
31860                         Glow             int8
31861                         MaxBreath        uint16  // Player only.
31862                         EyeHeight        float32 // Player only.
31863                         ZoomFOV          float32 // in degrees. Player only.
31864                         UseTextureAlpha  bool
31865                         DmgTextureMod    Texture // suffix
31866                         Shaded           bool
31867                         ShowOnMinimap    bool
31868                         NametagBG        color.NRGBA
31869                 }))(obj)).Glow
31870                 *p = int8(read8(r))
31871         }
31872         {
31873                 p := &(*(*(struct {
31874                         MaxHP            uint16 // Player only.
31875                         CollideWithNodes bool
31876                         Weight           float32 // deprecated
31877                         ColBox, SelBox   Box
31878                         Pointable        bool
31879                         Visual           string
31880                         VisualSize       [3]float32
31881                         Textures         []Texture
31882                         SpriteSheetSize  [2]int16 // in sprites.
31883                         SpritePos        [2]int16 // in sprite sheet.
31884                         Visible          bool
31885                         MakeFootstepSnds bool
31886                         RotateSpeed      float32 // in radians per second.
31887                         Mesh             string
31888                         Colors           []color.NRGBA
31889                         CollideWithAOs   bool
31890                         StepHeight       float32
31891                         FaceRotateDir    bool
31892                         FaceRotateDirOff float32 // in degrees.
31893                         BackfaceCull     bool
31894                         Nametag          string
31895                         NametagColor     color.NRGBA
31896                         FaceRotateSpeed  float32 // in degrees per second.
31897                         Infotext         string
31898                         Itemstring       string
31899                         Glow             int8
31900                         MaxBreath        uint16  // Player only.
31901                         EyeHeight        float32 // Player only.
31902                         ZoomFOV          float32 // in degrees. Player only.
31903                         UseTextureAlpha  bool
31904                         DmgTextureMod    Texture // suffix
31905                         Shaded           bool
31906                         ShowOnMinimap    bool
31907                         NametagBG        color.NRGBA
31908                 }))(obj)).MaxBreath
31909                 *p = read16(r)
31910         }
31911         {
31912                 p := &(*(*(struct {
31913                         MaxHP            uint16 // Player only.
31914                         CollideWithNodes bool
31915                         Weight           float32 // deprecated
31916                         ColBox, SelBox   Box
31917                         Pointable        bool
31918                         Visual           string
31919                         VisualSize       [3]float32
31920                         Textures         []Texture
31921                         SpriteSheetSize  [2]int16 // in sprites.
31922                         SpritePos        [2]int16 // in sprite sheet.
31923                         Visible          bool
31924                         MakeFootstepSnds bool
31925                         RotateSpeed      float32 // in radians per second.
31926                         Mesh             string
31927                         Colors           []color.NRGBA
31928                         CollideWithAOs   bool
31929                         StepHeight       float32
31930                         FaceRotateDir    bool
31931                         FaceRotateDirOff float32 // in degrees.
31932                         BackfaceCull     bool
31933                         Nametag          string
31934                         NametagColor     color.NRGBA
31935                         FaceRotateSpeed  float32 // in degrees per second.
31936                         Infotext         string
31937                         Itemstring       string
31938                         Glow             int8
31939                         MaxBreath        uint16  // Player only.
31940                         EyeHeight        float32 // Player only.
31941                         ZoomFOV          float32 // in degrees. Player only.
31942                         UseTextureAlpha  bool
31943                         DmgTextureMod    Texture // suffix
31944                         Shaded           bool
31945                         ShowOnMinimap    bool
31946                         NametagBG        color.NRGBA
31947                 }))(obj)).EyeHeight
31948                 *p = math.Float32frombits(read32(r))
31949         }
31950         {
31951                 p := &(*(*(struct {
31952                         MaxHP            uint16 // Player only.
31953                         CollideWithNodes bool
31954                         Weight           float32 // deprecated
31955                         ColBox, SelBox   Box
31956                         Pointable        bool
31957                         Visual           string
31958                         VisualSize       [3]float32
31959                         Textures         []Texture
31960                         SpriteSheetSize  [2]int16 // in sprites.
31961                         SpritePos        [2]int16 // in sprite sheet.
31962                         Visible          bool
31963                         MakeFootstepSnds bool
31964                         RotateSpeed      float32 // in radians per second.
31965                         Mesh             string
31966                         Colors           []color.NRGBA
31967                         CollideWithAOs   bool
31968                         StepHeight       float32
31969                         FaceRotateDir    bool
31970                         FaceRotateDirOff float32 // in degrees.
31971                         BackfaceCull     bool
31972                         Nametag          string
31973                         NametagColor     color.NRGBA
31974                         FaceRotateSpeed  float32 // in degrees per second.
31975                         Infotext         string
31976                         Itemstring       string
31977                         Glow             int8
31978                         MaxBreath        uint16  // Player only.
31979                         EyeHeight        float32 // Player only.
31980                         ZoomFOV          float32 // in degrees. Player only.
31981                         UseTextureAlpha  bool
31982                         DmgTextureMod    Texture // suffix
31983                         Shaded           bool
31984                         ShowOnMinimap    bool
31985                         NametagBG        color.NRGBA
31986                 }))(obj)).ZoomFOV
31987                 *p = math.Float32frombits(read32(r))
31988         }
31989         {
31990                 p := &(*(*(struct {
31991                         MaxHP            uint16 // Player only.
31992                         CollideWithNodes bool
31993                         Weight           float32 // deprecated
31994                         ColBox, SelBox   Box
31995                         Pointable        bool
31996                         Visual           string
31997                         VisualSize       [3]float32
31998                         Textures         []Texture
31999                         SpriteSheetSize  [2]int16 // in sprites.
32000                         SpritePos        [2]int16 // in sprite sheet.
32001                         Visible          bool
32002                         MakeFootstepSnds bool
32003                         RotateSpeed      float32 // in radians per second.
32004                         Mesh             string
32005                         Colors           []color.NRGBA
32006                         CollideWithAOs   bool
32007                         StepHeight       float32
32008                         FaceRotateDir    bool
32009                         FaceRotateDirOff float32 // in degrees.
32010                         BackfaceCull     bool
32011                         Nametag          string
32012                         NametagColor     color.NRGBA
32013                         FaceRotateSpeed  float32 // in degrees per second.
32014                         Infotext         string
32015                         Itemstring       string
32016                         Glow             int8
32017                         MaxBreath        uint16  // Player only.
32018                         EyeHeight        float32 // Player only.
32019                         ZoomFOV          float32 // in degrees. Player only.
32020                         UseTextureAlpha  bool
32021                         DmgTextureMod    Texture // suffix
32022                         Shaded           bool
32023                         ShowOnMinimap    bool
32024                         NametagBG        color.NRGBA
32025                 }))(obj)).UseTextureAlpha
32026                 switch n := read8(r); n {
32027                 case 0:
32028                         *p = false
32029                 case 1:
32030                         *p = true
32031                 default:
32032                         chk(fmt.Errorf("invalid bool: %d", n))
32033                 }
32034         }
32035         if err := pcall(func() {
32036                 ((*(*(struct {
32037                         MaxHP            uint16 // Player only.
32038                         CollideWithNodes bool
32039                         Weight           float32 // deprecated
32040                         ColBox, SelBox   Box
32041                         Pointable        bool
32042                         Visual           string
32043                         VisualSize       [3]float32
32044                         Textures         []Texture
32045                         SpriteSheetSize  [2]int16 // in sprites.
32046                         SpritePos        [2]int16 // in sprite sheet.
32047                         Visible          bool
32048                         MakeFootstepSnds bool
32049                         RotateSpeed      float32 // in radians per second.
32050                         Mesh             string
32051                         Colors           []color.NRGBA
32052                         CollideWithAOs   bool
32053                         StepHeight       float32
32054                         FaceRotateDir    bool
32055                         FaceRotateDirOff float32 // in degrees.
32056                         BackfaceCull     bool
32057                         Nametag          string
32058                         NametagColor     color.NRGBA
32059                         FaceRotateSpeed  float32 // in degrees per second.
32060                         Infotext         string
32061                         Itemstring       string
32062                         Glow             int8
32063                         MaxBreath        uint16  // Player only.
32064                         EyeHeight        float32 // Player only.
32065                         ZoomFOV          float32 // in degrees. Player only.
32066                         UseTextureAlpha  bool
32067                         DmgTextureMod    Texture // suffix
32068                         Shaded           bool
32069                         ShowOnMinimap    bool
32070                         NametagBG        color.NRGBA
32071                 }))(obj)).DmgTextureMod).deserialize(r)
32072         }); err != nil {
32073                 if err == io.EOF {
32074                         chk(io.EOF)
32075                 }
32076                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
32077         }
32078         {
32079                 p := &(*(*(struct {
32080                         MaxHP            uint16 // Player only.
32081                         CollideWithNodes bool
32082                         Weight           float32 // deprecated
32083                         ColBox, SelBox   Box
32084                         Pointable        bool
32085                         Visual           string
32086                         VisualSize       [3]float32
32087                         Textures         []Texture
32088                         SpriteSheetSize  [2]int16 // in sprites.
32089                         SpritePos        [2]int16 // in sprite sheet.
32090                         Visible          bool
32091                         MakeFootstepSnds bool
32092                         RotateSpeed      float32 // in radians per second.
32093                         Mesh             string
32094                         Colors           []color.NRGBA
32095                         CollideWithAOs   bool
32096                         StepHeight       float32
32097                         FaceRotateDir    bool
32098                         FaceRotateDirOff float32 // in degrees.
32099                         BackfaceCull     bool
32100                         Nametag          string
32101                         NametagColor     color.NRGBA
32102                         FaceRotateSpeed  float32 // in degrees per second.
32103                         Infotext         string
32104                         Itemstring       string
32105                         Glow             int8
32106                         MaxBreath        uint16  // Player only.
32107                         EyeHeight        float32 // Player only.
32108                         ZoomFOV          float32 // in degrees. Player only.
32109                         UseTextureAlpha  bool
32110                         DmgTextureMod    Texture // suffix
32111                         Shaded           bool
32112                         ShowOnMinimap    bool
32113                         NametagBG        color.NRGBA
32114                 }))(obj)).Shaded
32115                 switch n := read8(r); n {
32116                 case 0:
32117                         *p = false
32118                 case 1:
32119                         *p = true
32120                 default:
32121                         chk(fmt.Errorf("invalid bool: %d", n))
32122                 }
32123         }
32124         {
32125                 p := &(*(*(struct {
32126                         MaxHP            uint16 // Player only.
32127                         CollideWithNodes bool
32128                         Weight           float32 // deprecated
32129                         ColBox, SelBox   Box
32130                         Pointable        bool
32131                         Visual           string
32132                         VisualSize       [3]float32
32133                         Textures         []Texture
32134                         SpriteSheetSize  [2]int16 // in sprites.
32135                         SpritePos        [2]int16 // in sprite sheet.
32136                         Visible          bool
32137                         MakeFootstepSnds bool
32138                         RotateSpeed      float32 // in radians per second.
32139                         Mesh             string
32140                         Colors           []color.NRGBA
32141                         CollideWithAOs   bool
32142                         StepHeight       float32
32143                         FaceRotateDir    bool
32144                         FaceRotateDirOff float32 // in degrees.
32145                         BackfaceCull     bool
32146                         Nametag          string
32147                         NametagColor     color.NRGBA
32148                         FaceRotateSpeed  float32 // in degrees per second.
32149                         Infotext         string
32150                         Itemstring       string
32151                         Glow             int8
32152                         MaxBreath        uint16  // Player only.
32153                         EyeHeight        float32 // Player only.
32154                         ZoomFOV          float32 // in degrees. Player only.
32155                         UseTextureAlpha  bool
32156                         DmgTextureMod    Texture // suffix
32157                         Shaded           bool
32158                         ShowOnMinimap    bool
32159                         NametagBG        color.NRGBA
32160                 }))(obj)).ShowOnMinimap
32161                 switch n := read8(r); n {
32162                 case 0:
32163                         *p = false
32164                 case 1:
32165                         *p = true
32166                 default:
32167                         chk(fmt.Errorf("invalid bool: %d", n))
32168                 }
32169         }
32170         {
32171                 p := &(*(*(struct {
32172                         MaxHP            uint16 // Player only.
32173                         CollideWithNodes bool
32174                         Weight           float32 // deprecated
32175                         ColBox, SelBox   Box
32176                         Pointable        bool
32177                         Visual           string
32178                         VisualSize       [3]float32
32179                         Textures         []Texture
32180                         SpriteSheetSize  [2]int16 // in sprites.
32181                         SpritePos        [2]int16 // in sprite sheet.
32182                         Visible          bool
32183                         MakeFootstepSnds bool
32184                         RotateSpeed      float32 // in radians per second.
32185                         Mesh             string
32186                         Colors           []color.NRGBA
32187                         CollideWithAOs   bool
32188                         StepHeight       float32
32189                         FaceRotateDir    bool
32190                         FaceRotateDirOff float32 // in degrees.
32191                         BackfaceCull     bool
32192                         Nametag          string
32193                         NametagColor     color.NRGBA
32194                         FaceRotateSpeed  float32 // in degrees per second.
32195                         Infotext         string
32196                         Itemstring       string
32197                         Glow             int8
32198                         MaxBreath        uint16  // Player only.
32199                         EyeHeight        float32 // Player only.
32200                         ZoomFOV          float32 // in degrees. Player only.
32201                         UseTextureAlpha  bool
32202                         DmgTextureMod    Texture // suffix
32203                         Shaded           bool
32204                         ShowOnMinimap    bool
32205                         NametagBG        color.NRGBA
32206                 }))(obj)).NametagBG
32207                 *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
32208         }
32209 }
32210
32211 func (obj *AOPos) serialize(w io.Writer) {
32212         if err := pcall(func() {
32213                 ((*(*(struct {
32214                         Pos
32215                         Vel, Acc Vec
32216                         Rot      [3]float32
32217
32218                         Interpolate    bool
32219                         End            bool
32220                         UpdateInterval float32
32221                 }))(obj)).Pos).serialize(w)
32222         }); err != nil {
32223                 if err == io.EOF {
32224                         chk(io.EOF)
32225                 }
32226                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
32227         }
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)).Vel).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.Vec", 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)).Acc).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         for local358 := range (*(*(struct {
32261                 Pos
32262                 Vel, Acc Vec
32263                 Rot      [3]float32
32264
32265                 Interpolate    bool
32266                 End            bool
32267                 UpdateInterval float32
32268         }))(obj)).Rot {
32269                 {
32270                         x := ((*(*(struct {
32271                                 Pos
32272                                 Vel, Acc Vec
32273                                 Rot      [3]float32
32274
32275                                 Interpolate    bool
32276                                 End            bool
32277                                 UpdateInterval float32
32278                         }))(obj)).Rot)[local358]
32279                         write32(w, math.Float32bits(x))
32280                 }
32281         }
32282         {
32283                 x := (*(*(struct {
32284                         Pos
32285                         Vel, Acc Vec
32286                         Rot      [3]float32
32287
32288                         Interpolate    bool
32289                         End            bool
32290                         UpdateInterval float32
32291                 }))(obj)).Interpolate
32292                 if x {
32293                         write8(w, 1)
32294                 } else {
32295                         write8(w, 0)
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)).End
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)).UpdateInterval
32324                 write32(w, math.Float32bits(x))
32325         }
32326 }
32327
32328 func (obj *AOPos) deserialize(r io.Reader) {
32329         if err := pcall(func() {
32330                 ((*(*(struct {
32331                         Pos
32332                         Vel, Acc Vec
32333                         Rot      [3]float32
32334
32335                         Interpolate    bool
32336                         End            bool
32337                         UpdateInterval float32
32338                 }))(obj)).Pos).deserialize(r)
32339         }); err != nil {
32340                 if err == io.EOF {
32341                         chk(io.EOF)
32342                 }
32343                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
32344         }
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)).Vel).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.Vec", 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)).Acc).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         for local359 := range (*(*(struct {
32378                 Pos
32379                 Vel, Acc Vec
32380                 Rot      [3]float32
32381
32382                 Interpolate    bool
32383                 End            bool
32384                 UpdateInterval float32
32385         }))(obj)).Rot {
32386                 {
32387                         p := &((*(*(struct {
32388                                 Pos
32389                                 Vel, Acc Vec
32390                                 Rot      [3]float32
32391
32392                                 Interpolate    bool
32393                                 End            bool
32394                                 UpdateInterval float32
32395                         }))(obj)).Rot)[local359]
32396                         *p = math.Float32frombits(read32(r))
32397                 }
32398         }
32399         {
32400                 p := &(*(*(struct {
32401                         Pos
32402                         Vel, Acc Vec
32403                         Rot      [3]float32
32404
32405                         Interpolate    bool
32406                         End            bool
32407                         UpdateInterval float32
32408                 }))(obj)).Interpolate
32409                 switch n := read8(r); n {
32410                 case 0:
32411                         *p = false
32412                 case 1:
32413                         *p = true
32414                 default:
32415                         chk(fmt.Errorf("invalid bool: %d", n))
32416                 }
32417         }
32418         {
32419                 p := &(*(*(struct {
32420                         Pos
32421                         Vel, Acc Vec
32422                         Rot      [3]float32
32423
32424                         Interpolate    bool
32425                         End            bool
32426                         UpdateInterval float32
32427                 }))(obj)).End
32428                 switch n := read8(r); n {
32429                 case 0:
32430                         *p = false
32431                 case 1:
32432                         *p = true
32433                 default:
32434                         chk(fmt.Errorf("invalid bool: %d", n))
32435                 }
32436         }
32437         {
32438                 p := &(*(*(struct {
32439                         Pos
32440                         Vel, Acc Vec
32441                         Rot      [3]float32
32442
32443                         Interpolate    bool
32444                         End            bool
32445                         UpdateInterval float32
32446                 }))(obj)).UpdateInterval
32447                 *p = math.Float32frombits(read32(r))
32448         }
32449 }
32450
32451 func (obj *AOSprite) serialize(w io.Writer) {
32452         for local360 := range (*(*(struct {
32453                 Frame0          [2]int16
32454                 Frames          uint16
32455                 FrameDuration   float32
32456                 ViewAngleFrames bool
32457         }))(obj)).Frame0 {
32458                 {
32459                         x := ((*(*(struct {
32460                                 Frame0          [2]int16
32461                                 Frames          uint16
32462                                 FrameDuration   float32
32463                                 ViewAngleFrames bool
32464                         }))(obj)).Frame0)[local360]
32465                         write16(w, uint16(x))
32466                 }
32467         }
32468         {
32469                 x := (*(*(struct {
32470                         Frame0          [2]int16
32471                         Frames          uint16
32472                         FrameDuration   float32
32473                         ViewAngleFrames bool
32474                 }))(obj)).Frames
32475                 write16(w, uint16(x))
32476         }
32477         {
32478                 x := (*(*(struct {
32479                         Frame0          [2]int16
32480                         Frames          uint16
32481                         FrameDuration   float32
32482                         ViewAngleFrames bool
32483                 }))(obj)).FrameDuration
32484                 write32(w, math.Float32bits(x))
32485         }
32486         {
32487                 x := (*(*(struct {
32488                         Frame0          [2]int16
32489                         Frames          uint16
32490                         FrameDuration   float32
32491                         ViewAngleFrames bool
32492                 }))(obj)).ViewAngleFrames
32493                 if x {
32494                         write8(w, 1)
32495                 } else {
32496                         write8(w, 0)
32497                 }
32498         }
32499 }
32500
32501 func (obj *AOSprite) deserialize(r io.Reader) {
32502         for local361 := range (*(*(struct {
32503                 Frame0          [2]int16
32504                 Frames          uint16
32505                 FrameDuration   float32
32506                 ViewAngleFrames bool
32507         }))(obj)).Frame0 {
32508                 {
32509                         p := &((*(*(struct {
32510                                 Frame0          [2]int16
32511                                 Frames          uint16
32512                                 FrameDuration   float32
32513                                 ViewAngleFrames bool
32514                         }))(obj)).Frame0)[local361]
32515                         *p = int16(read16(r))
32516                 }
32517         }
32518         {
32519                 p := &(*(*(struct {
32520                         Frame0          [2]int16
32521                         Frames          uint16
32522                         FrameDuration   float32
32523                         ViewAngleFrames bool
32524                 }))(obj)).Frames
32525                 *p = read16(r)
32526         }
32527         {
32528                 p := &(*(*(struct {
32529                         Frame0          [2]int16
32530                         Frames          uint16
32531                         FrameDuration   float32
32532                         ViewAngleFrames bool
32533                 }))(obj)).FrameDuration
32534                 *p = math.Float32frombits(read32(r))
32535         }
32536         {
32537                 p := &(*(*(struct {
32538                         Frame0          [2]int16
32539                         Frames          uint16
32540                         FrameDuration   float32
32541                         ViewAngleFrames bool
32542                 }))(obj)).ViewAngleFrames
32543                 switch n := read8(r); n {
32544                 case 0:
32545                         *p = false
32546                 case 1:
32547                         *p = true
32548                 default:
32549                         chk(fmt.Errorf("invalid bool: %d", n))
32550                 }
32551         }
32552 }
32553
32554 func (obj *Group) serialize(w io.Writer) {
32555         if len(([]byte((*(*(struct {
32556                 Name   string
32557                 Rating int16
32558         }))(obj)).Name))) > math.MaxUint16 {
32559                 chk(ErrTooLong)
32560         }
32561         {
32562                 x := uint16(len(([]byte((*(*(struct {
32563                         Name   string
32564                         Rating int16
32565                 }))(obj)).Name))))
32566                 write16(w, uint16(x))
32567         }
32568         {
32569                 _, err := w.Write(([]byte((*(*(struct {
32570                         Name   string
32571                         Rating int16
32572                 }))(obj)).Name))[:])
32573                 chk(err)
32574         }
32575         {
32576                 x := (*(*(struct {
32577                         Name   string
32578                         Rating int16
32579                 }))(obj)).Rating
32580                 write16(w, uint16(x))
32581         }
32582 }
32583
32584 func (obj *Group) deserialize(r io.Reader) {
32585         var local362 []uint8
32586         var local363 uint16
32587         {
32588                 p := &local363
32589                 *p = read16(r)
32590         }
32591         (local362) = make([]uint8, local363)
32592         {
32593                 _, err := io.ReadFull(r, (local362)[:])
32594                 chk(err)
32595         }
32596         ((*(*(struct {
32597                 Name   string
32598                 Rating int16
32599         }))(obj)).Name) = string(local362)
32600         {
32601                 p := &(*(*(struct {
32602                         Name   string
32603                         Rating int16
32604                 }))(obj)).Rating
32605                 *p = int16(read16(r))
32606         }
32607 }
32608
32609 func (obj *AOAnim) serialize(w io.Writer) {
32610         for local364 := range (*(*(struct {
32611                 Frames [2]int32
32612                 Speed  float32
32613                 Blend  float32
32614                 NoLoop bool
32615         }))(obj)).Frames {
32616                 {
32617                         x := ((*(*(struct {
32618                                 Frames [2]int32
32619                                 Speed  float32
32620                                 Blend  float32
32621                                 NoLoop bool
32622                         }))(obj)).Frames)[local364]
32623                         write32(w, uint32(x))
32624                 }
32625         }
32626         {
32627                 x := (*(*(struct {
32628                         Frames [2]int32
32629                         Speed  float32
32630                         Blend  float32
32631                         NoLoop bool
32632                 }))(obj)).Speed
32633                 write32(w, math.Float32bits(x))
32634         }
32635         {
32636                 x := (*(*(struct {
32637                         Frames [2]int32
32638                         Speed  float32
32639                         Blend  float32
32640                         NoLoop bool
32641                 }))(obj)).Blend
32642                 write32(w, math.Float32bits(x))
32643         }
32644         {
32645                 x := (*(*(struct {
32646                         Frames [2]int32
32647                         Speed  float32
32648                         Blend  float32
32649                         NoLoop bool
32650                 }))(obj)).NoLoop
32651                 if x {
32652                         write8(w, 1)
32653                 } else {
32654                         write8(w, 0)
32655                 }
32656         }
32657 }
32658
32659 func (obj *AOAnim) deserialize(r io.Reader) {
32660         for local365 := range (*(*(struct {
32661                 Frames [2]int32
32662                 Speed  float32
32663                 Blend  float32
32664                 NoLoop bool
32665         }))(obj)).Frames {
32666                 {
32667                         p := &((*(*(struct {
32668                                 Frames [2]int32
32669                                 Speed  float32
32670                                 Blend  float32
32671                                 NoLoop bool
32672                         }))(obj)).Frames)[local365]
32673                         *p = int32(read32(r))
32674                 }
32675         }
32676         {
32677                 p := &(*(*(struct {
32678                         Frames [2]int32
32679                         Speed  float32
32680                         Blend  float32
32681                         NoLoop bool
32682                 }))(obj)).Speed
32683                 *p = math.Float32frombits(read32(r))
32684         }
32685         {
32686                 p := &(*(*(struct {
32687                         Frames [2]int32
32688                         Speed  float32
32689                         Blend  float32
32690                         NoLoop bool
32691                 }))(obj)).Blend
32692                 *p = math.Float32frombits(read32(r))
32693         }
32694         {
32695                 p := &(*(*(struct {
32696                         Frames [2]int32
32697                         Speed  float32
32698                         Blend  float32
32699                         NoLoop bool
32700                 }))(obj)).NoLoop
32701                 switch n := read8(r); n {
32702                 case 0:
32703                         *p = false
32704                 case 1:
32705                         *p = true
32706                 default:
32707                         chk(fmt.Errorf("invalid bool: %d", n))
32708                 }
32709         }
32710 }
32711
32712 func (obj *AOBonePos) serialize(w io.Writer) {
32713         if err := pcall(func() {
32714                 ((*(*(struct {
32715                         Pos Vec
32716                         Rot [3]float32
32717                 }))(obj)).Pos).serialize(w)
32718         }); err != nil {
32719                 if err == io.EOF {
32720                         chk(io.EOF)
32721                 }
32722                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32723         }
32724         for local366 := range (*(*(struct {
32725                 Pos Vec
32726                 Rot [3]float32
32727         }))(obj)).Rot {
32728                 {
32729                         x := ((*(*(struct {
32730                                 Pos Vec
32731                                 Rot [3]float32
32732                         }))(obj)).Rot)[local366]
32733                         write32(w, math.Float32bits(x))
32734                 }
32735         }
32736 }
32737
32738 func (obj *AOBonePos) deserialize(r io.Reader) {
32739         if err := pcall(func() {
32740                 ((*(*(struct {
32741                         Pos Vec
32742                         Rot [3]float32
32743                 }))(obj)).Pos).deserialize(r)
32744         }); err != nil {
32745                 if err == io.EOF {
32746                         chk(io.EOF)
32747                 }
32748                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32749         }
32750         for local367 := range (*(*(struct {
32751                 Pos Vec
32752                 Rot [3]float32
32753         }))(obj)).Rot {
32754                 {
32755                         p := &((*(*(struct {
32756                                 Pos Vec
32757                                 Rot [3]float32
32758                         }))(obj)).Rot)[local367]
32759                         *p = math.Float32frombits(read32(r))
32760                 }
32761         }
32762 }
32763
32764 func (obj *AOAttach) serialize(w io.Writer) {
32765         if err := pcall(func() {
32766                 ((*(*(struct {
32767                         ParentID     AOID
32768                         Bone         string
32769                         Pos          Vec
32770                         Rot          [3]float32
32771                         ForceVisible bool
32772                 }))(obj)).ParentID).serialize(w)
32773         }); err != nil {
32774                 if err == io.EOF {
32775                         chk(io.EOF)
32776                 }
32777                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
32778         }
32779         if len(([]byte((*(*(struct {
32780                 ParentID     AOID
32781                 Bone         string
32782                 Pos          Vec
32783                 Rot          [3]float32
32784                 ForceVisible bool
32785         }))(obj)).Bone))) > math.MaxUint16 {
32786                 chk(ErrTooLong)
32787         }
32788         {
32789                 x := uint16(len(([]byte((*(*(struct {
32790                         ParentID     AOID
32791                         Bone         string
32792                         Pos          Vec
32793                         Rot          [3]float32
32794                         ForceVisible bool
32795                 }))(obj)).Bone))))
32796                 write16(w, uint16(x))
32797         }
32798         {
32799                 _, err := w.Write(([]byte((*(*(struct {
32800                         ParentID     AOID
32801                         Bone         string
32802                         Pos          Vec
32803                         Rot          [3]float32
32804                         ForceVisible bool
32805                 }))(obj)).Bone))[:])
32806                 chk(err)
32807         }
32808         if err := pcall(func() {
32809                 ((*(*(struct {
32810                         ParentID     AOID
32811                         Bone         string
32812                         Pos          Vec
32813                         Rot          [3]float32
32814                         ForceVisible bool
32815                 }))(obj)).Pos).serialize(w)
32816         }); err != nil {
32817                 if err == io.EOF {
32818                         chk(io.EOF)
32819                 }
32820                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32821         }
32822         for local368 := range (*(*(struct {
32823                 ParentID     AOID
32824                 Bone         string
32825                 Pos          Vec
32826                 Rot          [3]float32
32827                 ForceVisible bool
32828         }))(obj)).Rot {
32829                 {
32830                         x := ((*(*(struct {
32831                                 ParentID     AOID
32832                                 Bone         string
32833                                 Pos          Vec
32834                                 Rot          [3]float32
32835                                 ForceVisible bool
32836                         }))(obj)).Rot)[local368]
32837                         write32(w, math.Float32bits(x))
32838                 }
32839         }
32840         {
32841                 x := (*(*(struct {
32842                         ParentID     AOID
32843                         Bone         string
32844                         Pos          Vec
32845                         Rot          [3]float32
32846                         ForceVisible bool
32847                 }))(obj)).ForceVisible
32848                 if x {
32849                         write8(w, 1)
32850                 } else {
32851                         write8(w, 0)
32852                 }
32853         }
32854 }
32855
32856 func (obj *AOAttach) deserialize(r io.Reader) {
32857         if err := pcall(func() {
32858                 ((*(*(struct {
32859                         ParentID     AOID
32860                         Bone         string
32861                         Pos          Vec
32862                         Rot          [3]float32
32863                         ForceVisible bool
32864                 }))(obj)).ParentID).deserialize(r)
32865         }); err != nil {
32866                 if err == io.EOF {
32867                         chk(io.EOF)
32868                 }
32869                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
32870         }
32871         var local369 []uint8
32872         var local370 uint16
32873         {
32874                 p := &local370
32875                 *p = read16(r)
32876         }
32877         (local369) = make([]uint8, local370)
32878         {
32879                 _, err := io.ReadFull(r, (local369)[:])
32880                 chk(err)
32881         }
32882         ((*(*(struct {
32883                 ParentID     AOID
32884                 Bone         string
32885                 Pos          Vec
32886                 Rot          [3]float32
32887                 ForceVisible bool
32888         }))(obj)).Bone) = string(local369)
32889         if err := pcall(func() {
32890                 ((*(*(struct {
32891                         ParentID     AOID
32892                         Bone         string
32893                         Pos          Vec
32894                         Rot          [3]float32
32895                         ForceVisible bool
32896                 }))(obj)).Pos).deserialize(r)
32897         }); err != nil {
32898                 if err == io.EOF {
32899                         chk(io.EOF)
32900                 }
32901                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
32902         }
32903         for local371 := range (*(*(struct {
32904                 ParentID     AOID
32905                 Bone         string
32906                 Pos          Vec
32907                 Rot          [3]float32
32908                 ForceVisible bool
32909         }))(obj)).Rot {
32910                 {
32911                         p := &((*(*(struct {
32912                                 ParentID     AOID
32913                                 Bone         string
32914                                 Pos          Vec
32915                                 Rot          [3]float32
32916                                 ForceVisible bool
32917                         }))(obj)).Rot)[local371]
32918                         *p = math.Float32frombits(read32(r))
32919                 }
32920         }
32921         {
32922                 p := &(*(*(struct {
32923                         ParentID     AOID
32924                         Bone         string
32925                         Pos          Vec
32926                         Rot          [3]float32
32927                         ForceVisible bool
32928                 }))(obj)).ForceVisible
32929                 switch n := read8(r); n {
32930                 case 0:
32931                         *p = false
32932                 case 1:
32933                         *p = true
32934                 default:
32935                         chk(fmt.Errorf("invalid bool: %d", n))
32936                 }
32937         }
32938 }
32939
32940 func (obj *AOPhysOverride) serialize(w io.Writer) {
32941         {
32942                 x := (*(*(struct {
32943                         Walk, Jump, Gravity float32
32944
32945                         // Player only.
32946                         NoSneak, NoSneakGlitch, OldSneak bool
32947                 }))(obj)).Walk
32948                 write32(w, math.Float32bits(x))
32949         }
32950         {
32951                 x := (*(*(struct {
32952                         Walk, Jump, Gravity float32
32953
32954                         // Player only.
32955                         NoSneak, NoSneakGlitch, OldSneak bool
32956                 }))(obj)).Jump
32957                 write32(w, math.Float32bits(x))
32958         }
32959         {
32960                 x := (*(*(struct {
32961                         Walk, Jump, Gravity float32
32962
32963                         // Player only.
32964                         NoSneak, NoSneakGlitch, OldSneak bool
32965                 }))(obj)).Gravity
32966                 write32(w, math.Float32bits(x))
32967         }
32968         {
32969                 x := (*(*(struct {
32970                         Walk, Jump, Gravity float32
32971
32972                         // Player only.
32973                         NoSneak, NoSneakGlitch, OldSneak bool
32974                 }))(obj)).NoSneak
32975                 if x {
32976                         write8(w, 1)
32977                 } else {
32978                         write8(w, 0)
32979                 }
32980         }
32981         {
32982                 x := (*(*(struct {
32983                         Walk, Jump, Gravity float32
32984
32985                         // Player only.
32986                         NoSneak, NoSneakGlitch, OldSneak bool
32987                 }))(obj)).NoSneakGlitch
32988                 if x {
32989                         write8(w, 1)
32990                 } else {
32991                         write8(w, 0)
32992                 }
32993         }
32994         {
32995                 x := (*(*(struct {
32996                         Walk, Jump, Gravity float32
32997
32998                         // Player only.
32999                         NoSneak, NoSneakGlitch, OldSneak bool
33000                 }))(obj)).OldSneak
33001                 if x {
33002                         write8(w, 1)
33003                 } else {
33004                         write8(w, 0)
33005                 }
33006         }
33007 }
33008
33009 func (obj *AOPhysOverride) deserialize(r io.Reader) {
33010         {
33011                 p := &(*(*(struct {
33012                         Walk, Jump, Gravity float32
33013
33014                         // Player only.
33015                         NoSneak, NoSneakGlitch, OldSneak bool
33016                 }))(obj)).Walk
33017                 *p = math.Float32frombits(read32(r))
33018         }
33019         {
33020                 p := &(*(*(struct {
33021                         Walk, Jump, Gravity float32
33022
33023                         // Player only.
33024                         NoSneak, NoSneakGlitch, OldSneak bool
33025                 }))(obj)).Jump
33026                 *p = math.Float32frombits(read32(r))
33027         }
33028         {
33029                 p := &(*(*(struct {
33030                         Walk, Jump, Gravity float32
33031
33032                         // Player only.
33033                         NoSneak, NoSneakGlitch, OldSneak bool
33034                 }))(obj)).Gravity
33035                 *p = math.Float32frombits(read32(r))
33036         }
33037         {
33038                 p := &(*(*(struct {
33039                         Walk, Jump, Gravity float32
33040
33041                         // Player only.
33042                         NoSneak, NoSneakGlitch, OldSneak bool
33043                 }))(obj)).NoSneak
33044                 switch n := read8(r); n {
33045                 case 0:
33046                         *p = false
33047                 case 1:
33048                         *p = true
33049                 default:
33050                         chk(fmt.Errorf("invalid bool: %d", n))
33051                 }
33052         }
33053         {
33054                 p := &(*(*(struct {
33055                         Walk, Jump, Gravity float32
33056
33057                         // Player only.
33058                         NoSneak, NoSneakGlitch, OldSneak bool
33059                 }))(obj)).NoSneakGlitch
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)).OldSneak
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
33087 func (obj *aoType) serialize(w io.Writer) {
33088         {
33089                 x := *(*(uint8))(obj)
33090                 write8(w, uint8(x))
33091         }
33092 }
33093
33094 func (obj *aoType) deserialize(r io.Reader) {
33095         {
33096                 p := &*(*(uint8))(obj)
33097                 *p = read8(r)
33098         }
33099 }
33100
33101 func (obj *NodeMetaField) serialize(w io.Writer) {
33102         if err := pcall(func() {
33103                 ((*(*(struct {
33104                         Field
33105                         Private bool
33106                 }))(obj)).Field).serialize(w)
33107         }); err != nil {
33108                 if err == io.EOF {
33109                         chk(io.EOF)
33110                 }
33111                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
33112         }
33113         {
33114                 x := (*(*(struct {
33115                         Field
33116                         Private bool
33117                 }))(obj)).Private
33118                 if x {
33119                         write8(w, 1)
33120                 } else {
33121                         write8(w, 0)
33122                 }
33123         }
33124 }
33125
33126 func (obj *NodeMetaField) deserialize(r io.Reader) {
33127         if err := pcall(func() {
33128                 ((*(*(struct {
33129                         Field
33130                         Private bool
33131                 }))(obj)).Field).deserialize(r)
33132         }); err != nil {
33133                 if err == io.EOF {
33134                         chk(io.EOF)
33135                 }
33136                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Field", err))
33137         }
33138         {
33139                 p := &(*(*(struct {
33140                         Field
33141                         Private bool
33142                 }))(obj)).Private
33143                 switch n := read8(r); n {
33144                 case 0:
33145                         *p = false
33146                 case 1:
33147                         *p = true
33148                 default:
33149                         chk(fmt.Errorf("invalid bool: %d", n))
33150                 }
33151         }
33152 }
33153
33154 func (obj *MinimapType) serialize(w io.Writer) {
33155         {
33156                 x := *(*(uint16))(obj)
33157                 write16(w, uint16(x))
33158         }
33159 }
33160
33161 func (obj *MinimapType) deserialize(r io.Reader) {
33162         {
33163                 p := &*(*(uint16))(obj)
33164                 *p = read16(r)
33165         }
33166 }
33167
33168 func (obj *Param1Type) serialize(w io.Writer) {
33169         {
33170                 x := *(*(uint8))(obj)
33171                 write8(w, uint8(x))
33172         }
33173 }
33174
33175 func (obj *Param1Type) deserialize(r io.Reader) {
33176         {
33177                 p := &*(*(uint8))(obj)
33178                 *p = read8(r)
33179         }
33180 }
33181
33182 func (obj *Param2Type) serialize(w io.Writer) {
33183         {
33184                 x := *(*(uint8))(obj)
33185                 write8(w, uint8(x))
33186         }
33187 }
33188
33189 func (obj *Param2Type) deserialize(r io.Reader) {
33190         {
33191                 p := &*(*(uint8))(obj)
33192                 *p = read8(r)
33193         }
33194 }
33195
33196 func (obj *DrawType) serialize(w io.Writer) {
33197         {
33198                 x := *(*(uint8))(obj)
33199                 write8(w, uint8(x))
33200         }
33201 }
33202
33203 func (obj *DrawType) deserialize(r io.Reader) {
33204         {
33205                 p := &*(*(uint8))(obj)
33206                 *p = read8(r)
33207         }
33208 }
33209
33210 func (obj *TileDef) serialize(w io.Writer) {
33211         {
33212                 local372 := uint8(6)
33213                 {
33214                         x := local372
33215                         write8(w, uint8(x))
33216                 }
33217         }
33218         if err := pcall(func() {
33219                 ((*(*(struct {
33220                         Texture
33221                         Anim  TileAnim
33222                         Flags TileFlags
33223
33224                         //mt:if %s.Flags&TileColor != 0
33225                         R, G, B uint8
33226
33227                         //mt:if %s.Flags&TileScale != 0
33228                         Scale uint8
33229
33230                         //mt:if %s.Flags&TileAlign != 0
33231                         Align AlignType
33232                 }))(obj)).Texture).serialize(w)
33233         }); err != nil {
33234                 if err == io.EOF {
33235                         chk(io.EOF)
33236                 }
33237                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
33238         }
33239         if err := pcall(func() {
33240                 ((*(*(struct {
33241                         Texture
33242                         Anim  TileAnim
33243                         Flags TileFlags
33244
33245                         //mt:if %s.Flags&TileColor != 0
33246                         R, G, B uint8
33247
33248                         //mt:if %s.Flags&TileScale != 0
33249                         Scale uint8
33250
33251                         //mt:if %s.Flags&TileAlign != 0
33252                         Align AlignType
33253                 }))(obj)).Anim).serialize(w)
33254         }); err != nil {
33255                 if err == io.EOF {
33256                         chk(io.EOF)
33257                 }
33258                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
33259         }
33260         if err := pcall(func() {
33261                 ((*(*(struct {
33262                         Texture
33263                         Anim  TileAnim
33264                         Flags TileFlags
33265
33266                         //mt:if %s.Flags&TileColor != 0
33267                         R, G, B uint8
33268
33269                         //mt:if %s.Flags&TileScale != 0
33270                         Scale uint8
33271
33272                         //mt:if %s.Flags&TileAlign != 0
33273                         Align AlignType
33274                 }))(obj)).Flags).serialize(w)
33275         }); err != nil {
33276                 if err == io.EOF {
33277                         chk(io.EOF)
33278                 }
33279                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
33280         }
33281         if (*(*(struct {
33282                 Texture
33283                 Anim  TileAnim
33284                 Flags TileFlags
33285
33286                 //mt:if %s.Flags&TileColor != 0
33287                 R, G, B uint8
33288
33289                 //mt:if %s.Flags&TileScale != 0
33290                 Scale uint8
33291
33292                 //mt:if %s.Flags&TileAlign != 0
33293                 Align AlignType
33294         }))(obj)).Flags&TileColor != 0 {
33295                 {
33296                         x := (*(*(struct {
33297                                 Texture
33298                                 Anim  TileAnim
33299                                 Flags TileFlags
33300
33301                                 //mt:if %s.Flags&TileColor != 0
33302                                 R, G, B uint8
33303
33304                                 //mt:if %s.Flags&TileScale != 0
33305                                 Scale uint8
33306
33307                                 //mt:if %s.Flags&TileAlign != 0
33308                                 Align AlignType
33309                         }))(obj)).R
33310                         write8(w, uint8(x))
33311                 }
33312                 {
33313                         x := (*(*(struct {
33314                                 Texture
33315                                 Anim  TileAnim
33316                                 Flags TileFlags
33317
33318                                 //mt:if %s.Flags&TileColor != 0
33319                                 R, G, B uint8
33320
33321                                 //mt:if %s.Flags&TileScale != 0
33322                                 Scale uint8
33323
33324                                 //mt:if %s.Flags&TileAlign != 0
33325                                 Align AlignType
33326                         }))(obj)).G
33327                         write8(w, uint8(x))
33328                 }
33329                 {
33330                         x := (*(*(struct {
33331                                 Texture
33332                                 Anim  TileAnim
33333                                 Flags TileFlags
33334
33335                                 //mt:if %s.Flags&TileColor != 0
33336                                 R, G, B uint8
33337
33338                                 //mt:if %s.Flags&TileScale != 0
33339                                 Scale uint8
33340
33341                                 //mt:if %s.Flags&TileAlign != 0
33342                                 Align AlignType
33343                         }))(obj)).B
33344                         write8(w, uint8(x))
33345                 }
33346         }
33347         if (*(*(struct {
33348                 Texture
33349                 Anim  TileAnim
33350                 Flags TileFlags
33351
33352                 //mt:if %s.Flags&TileColor != 0
33353                 R, G, B uint8
33354
33355                 //mt:if %s.Flags&TileScale != 0
33356                 Scale uint8
33357
33358                 //mt:if %s.Flags&TileAlign != 0
33359                 Align AlignType
33360         }))(obj)).Flags&TileScale != 0 {
33361                 {
33362                         x := (*(*(struct {
33363                                 Texture
33364                                 Anim  TileAnim
33365                                 Flags TileFlags
33366
33367                                 //mt:if %s.Flags&TileColor != 0
33368                                 R, G, B uint8
33369
33370                                 //mt:if %s.Flags&TileScale != 0
33371                                 Scale uint8
33372
33373                                 //mt:if %s.Flags&TileAlign != 0
33374                                 Align AlignType
33375                         }))(obj)).Scale
33376                         write8(w, uint8(x))
33377                 }
33378         }
33379         if (*(*(struct {
33380                 Texture
33381                 Anim  TileAnim
33382                 Flags TileFlags
33383
33384                 //mt:if %s.Flags&TileColor != 0
33385                 R, G, B uint8
33386
33387                 //mt:if %s.Flags&TileScale != 0
33388                 Scale uint8
33389
33390                 //mt:if %s.Flags&TileAlign != 0
33391                 Align AlignType
33392         }))(obj)).Flags&TileAlign != 0 {
33393                 if err := pcall(func() {
33394                         ((*(*(struct {
33395                                 Texture
33396                                 Anim  TileAnim
33397                                 Flags TileFlags
33398
33399                                 //mt:if %s.Flags&TileColor != 0
33400                                 R, G, B uint8
33401
33402                                 //mt:if %s.Flags&TileScale != 0
33403                                 Scale uint8
33404
33405                                 //mt:if %s.Flags&TileAlign != 0
33406                                 Align AlignType
33407                         }))(obj)).Align).serialize(w)
33408                 }); err != nil {
33409                         if err == io.EOF {
33410                                 chk(io.EOF)
33411                         }
33412                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
33413                 }
33414         }
33415 }
33416
33417 func (obj *TileDef) deserialize(r io.Reader) {
33418         {
33419                 var local373 uint8
33420                 local374 := uint8(6)
33421                 {
33422                         p := &local373
33423                         *p = read8(r)
33424                 }
33425                 if local373 != local374 {
33426                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local373))
33427                 }
33428         }
33429         if err := pcall(func() {
33430                 ((*(*(struct {
33431                         Texture
33432                         Anim  TileAnim
33433                         Flags TileFlags
33434
33435                         //mt:if %s.Flags&TileColor != 0
33436                         R, G, B uint8
33437
33438                         //mt:if %s.Flags&TileScale != 0
33439                         Scale uint8
33440
33441                         //mt:if %s.Flags&TileAlign != 0
33442                         Align AlignType
33443                 }))(obj)).Texture).deserialize(r)
33444         }); err != nil {
33445                 if err == io.EOF {
33446                         chk(io.EOF)
33447                 }
33448                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Texture", err))
33449         }
33450         if err := pcall(func() {
33451                 ((*(*(struct {
33452                         Texture
33453                         Anim  TileAnim
33454                         Flags TileFlags
33455
33456                         //mt:if %s.Flags&TileColor != 0
33457                         R, G, B uint8
33458
33459                         //mt:if %s.Flags&TileScale != 0
33460                         Scale uint8
33461
33462                         //mt:if %s.Flags&TileAlign != 0
33463                         Align AlignType
33464                 }))(obj)).Anim).deserialize(r)
33465         }); err != nil {
33466                 if err == io.EOF {
33467                         chk(io.EOF)
33468                 }
33469                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileAnim", err))
33470         }
33471         if err := pcall(func() {
33472                 ((*(*(struct {
33473                         Texture
33474                         Anim  TileAnim
33475                         Flags TileFlags
33476
33477                         //mt:if %s.Flags&TileColor != 0
33478                         R, G, B uint8
33479
33480                         //mt:if %s.Flags&TileScale != 0
33481                         Scale uint8
33482
33483                         //mt:if %s.Flags&TileAlign != 0
33484                         Align AlignType
33485                 }))(obj)).Flags).deserialize(r)
33486         }); err != nil {
33487                 if err == io.EOF {
33488                         chk(io.EOF)
33489                 }
33490                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.TileFlags", err))
33491         }
33492         if (*(*(struct {
33493                 Texture
33494                 Anim  TileAnim
33495                 Flags TileFlags
33496
33497                 //mt:if %s.Flags&TileColor != 0
33498                 R, G, B uint8
33499
33500                 //mt:if %s.Flags&TileScale != 0
33501                 Scale uint8
33502
33503                 //mt:if %s.Flags&TileAlign != 0
33504                 Align AlignType
33505         }))(obj)).Flags&TileColor != 0 {
33506                 {
33507                         p := &(*(*(struct {
33508                                 Texture
33509                                 Anim  TileAnim
33510                                 Flags TileFlags
33511
33512                                 //mt:if %s.Flags&TileColor != 0
33513                                 R, G, B uint8
33514
33515                                 //mt:if %s.Flags&TileScale != 0
33516                                 Scale uint8
33517
33518                                 //mt:if %s.Flags&TileAlign != 0
33519                                 Align AlignType
33520                         }))(obj)).R
33521                         *p = read8(r)
33522                 }
33523                 {
33524                         p := &(*(*(struct {
33525                                 Texture
33526                                 Anim  TileAnim
33527                                 Flags TileFlags
33528
33529                                 //mt:if %s.Flags&TileColor != 0
33530                                 R, G, B uint8
33531
33532                                 //mt:if %s.Flags&TileScale != 0
33533                                 Scale uint8
33534
33535                                 //mt:if %s.Flags&TileAlign != 0
33536                                 Align AlignType
33537                         }))(obj)).G
33538                         *p = read8(r)
33539                 }
33540                 {
33541                         p := &(*(*(struct {
33542                                 Texture
33543                                 Anim  TileAnim
33544                                 Flags TileFlags
33545
33546                                 //mt:if %s.Flags&TileColor != 0
33547                                 R, G, B uint8
33548
33549                                 //mt:if %s.Flags&TileScale != 0
33550                                 Scale uint8
33551
33552                                 //mt:if %s.Flags&TileAlign != 0
33553                                 Align AlignType
33554                         }))(obj)).B
33555                         *p = read8(r)
33556                 }
33557         }
33558         if (*(*(struct {
33559                 Texture
33560                 Anim  TileAnim
33561                 Flags TileFlags
33562
33563                 //mt:if %s.Flags&TileColor != 0
33564                 R, G, B uint8
33565
33566                 //mt:if %s.Flags&TileScale != 0
33567                 Scale uint8
33568
33569                 //mt:if %s.Flags&TileAlign != 0
33570                 Align AlignType
33571         }))(obj)).Flags&TileScale != 0 {
33572                 {
33573                         p := &(*(*(struct {
33574                                 Texture
33575                                 Anim  TileAnim
33576                                 Flags TileFlags
33577
33578                                 //mt:if %s.Flags&TileColor != 0
33579                                 R, G, B uint8
33580
33581                                 //mt:if %s.Flags&TileScale != 0
33582                                 Scale uint8
33583
33584                                 //mt:if %s.Flags&TileAlign != 0
33585                                 Align AlignType
33586                         }))(obj)).Scale
33587                         *p = read8(r)
33588                 }
33589         }
33590         if (*(*(struct {
33591                 Texture
33592                 Anim  TileAnim
33593                 Flags TileFlags
33594
33595                 //mt:if %s.Flags&TileColor != 0
33596                 R, G, B uint8
33597
33598                 //mt:if %s.Flags&TileScale != 0
33599                 Scale uint8
33600
33601                 //mt:if %s.Flags&TileAlign != 0
33602                 Align AlignType
33603         }))(obj)).Flags&TileAlign != 0 {
33604                 if err := pcall(func() {
33605                         ((*(*(struct {
33606                                 Texture
33607                                 Anim  TileAnim
33608                                 Flags TileFlags
33609
33610                                 //mt:if %s.Flags&TileColor != 0
33611                                 R, G, B uint8
33612
33613                                 //mt:if %s.Flags&TileScale != 0
33614                                 Scale uint8
33615
33616                                 //mt:if %s.Flags&TileAlign != 0
33617                                 Align AlignType
33618                         }))(obj)).Align).deserialize(r)
33619                 }); err != nil {
33620                         if err == io.EOF {
33621                                 chk(io.EOF)
33622                         }
33623                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AlignType", err))
33624                 }
33625         }
33626 }
33627
33628 func (obj *WaveType) serialize(w io.Writer) {
33629         {
33630                 x := *(*(uint8))(obj)
33631                 write8(w, uint8(x))
33632         }
33633 }
33634
33635 func (obj *WaveType) deserialize(r io.Reader) {
33636         {
33637                 p := &*(*(uint8))(obj)
33638                 *p = read8(r)
33639         }
33640 }
33641
33642 func (obj *LiquidType) serialize(w io.Writer) {
33643         {
33644                 x := *(*(uint8))(obj)
33645                 write8(w, uint8(x))
33646         }
33647 }
33648
33649 func (obj *LiquidType) deserialize(r io.Reader) {
33650         {
33651                 p := &*(*(uint8))(obj)
33652                 *p = read8(r)
33653         }
33654 }
33655
33656 func (obj *NodeBox) serialize(w io.Writer) {
33657         {
33658                 local375 := uint8(6)
33659                 {
33660                         x := local375
33661                         write8(w, uint8(x))
33662                 }
33663         }
33664         if err := pcall(func() {
33665                 ((*(*(struct {
33666                         Type NodeBoxType
33667
33668                         //mt:if %s.Type == MountedBox
33669                         WallTop, WallBot, WallSides Box
33670
33671                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33672                         Fixed []Box
33673
33674                         //mt:if %s.Type == ConnectedBox
33675                         ConnDirs, DiscoDirs  DirBoxes
33676                         DiscoAll, DiscoSides []Box
33677                 }))(obj)).Type).serialize(w)
33678         }); err != nil {
33679                 if err == io.EOF {
33680                         chk(io.EOF)
33681                 }
33682                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
33683         }
33684         if !((*(*(struct {
33685                 Type NodeBoxType
33686
33687                 //mt:if %s.Type == MountedBox
33688                 WallTop, WallBot, WallSides Box
33689
33690                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33691                 Fixed []Box
33692
33693                 //mt:if %s.Type == ConnectedBox
33694                 ConnDirs, DiscoDirs  DirBoxes
33695                 DiscoAll, DiscoSides []Box
33696         }))(obj)).Type < maxBox) {
33697                 chk(errors.New("assertion failed: %s.Type < maxBox"))
33698         }
33699         if (*(*(struct {
33700                 Type NodeBoxType
33701
33702                 //mt:if %s.Type == MountedBox
33703                 WallTop, WallBot, WallSides Box
33704
33705                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33706                 Fixed []Box
33707
33708                 //mt:if %s.Type == ConnectedBox
33709                 ConnDirs, DiscoDirs  DirBoxes
33710                 DiscoAll, DiscoSides []Box
33711         }))(obj)).Type == MountedBox {
33712                 if err := pcall(func() {
33713                         ((*(*(struct {
33714                                 Type NodeBoxType
33715
33716                                 //mt:if %s.Type == MountedBox
33717                                 WallTop, WallBot, WallSides Box
33718
33719                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33720                                 Fixed []Box
33721
33722                                 //mt:if %s.Type == ConnectedBox
33723                                 ConnDirs, DiscoDirs  DirBoxes
33724                                 DiscoAll, DiscoSides []Box
33725                         }))(obj)).WallTop).serialize(w)
33726                 }); err != nil {
33727                         if err == io.EOF {
33728                                 chk(io.EOF)
33729                         }
33730                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33731                 }
33732                 if err := pcall(func() {
33733                         ((*(*(struct {
33734                                 Type NodeBoxType
33735
33736                                 //mt:if %s.Type == MountedBox
33737                                 WallTop, WallBot, WallSides Box
33738
33739                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33740                                 Fixed []Box
33741
33742                                 //mt:if %s.Type == ConnectedBox
33743                                 ConnDirs, DiscoDirs  DirBoxes
33744                                 DiscoAll, DiscoSides []Box
33745                         }))(obj)).WallBot).serialize(w)
33746                 }); err != nil {
33747                         if err == io.EOF {
33748                                 chk(io.EOF)
33749                         }
33750                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33751                 }
33752                 if err := pcall(func() {
33753                         ((*(*(struct {
33754                                 Type NodeBoxType
33755
33756                                 //mt:if %s.Type == MountedBox
33757                                 WallTop, WallBot, WallSides Box
33758
33759                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33760                                 Fixed []Box
33761
33762                                 //mt:if %s.Type == ConnectedBox
33763                                 ConnDirs, DiscoDirs  DirBoxes
33764                                 DiscoAll, DiscoSides []Box
33765                         }))(obj)).WallSides).serialize(w)
33766                 }); err != nil {
33767                         if err == io.EOF {
33768                                 chk(io.EOF)
33769                         }
33770                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33771                 }
33772         }
33773         if t := (*(*(struct {
33774                 Type NodeBoxType
33775
33776                 //mt:if %s.Type == MountedBox
33777                 WallTop, WallBot, WallSides Box
33778
33779                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33780                 Fixed []Box
33781
33782                 //mt:if %s.Type == ConnectedBox
33783                 ConnDirs, DiscoDirs  DirBoxes
33784                 DiscoAll, DiscoSides []Box
33785         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
33786                 if len(((*(*(struct {
33787                         Type NodeBoxType
33788
33789                         //mt:if %s.Type == MountedBox
33790                         WallTop, WallBot, WallSides Box
33791
33792                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33793                         Fixed []Box
33794
33795                         //mt:if %s.Type == ConnectedBox
33796                         ConnDirs, DiscoDirs  DirBoxes
33797                         DiscoAll, DiscoSides []Box
33798                 }))(obj)).Fixed)) > math.MaxUint16 {
33799                         chk(ErrTooLong)
33800                 }
33801                 {
33802                         x := uint16(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)))
33815                         write16(w, uint16(x))
33816                 }
33817                 for local376 := range (*(*(struct {
33818                         Type NodeBoxType
33819
33820                         //mt:if %s.Type == MountedBox
33821                         WallTop, WallBot, WallSides Box
33822
33823                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33824                         Fixed []Box
33825
33826                         //mt:if %s.Type == ConnectedBox
33827                         ConnDirs, DiscoDirs  DirBoxes
33828                         DiscoAll, DiscoSides []Box
33829                 }))(obj)).Fixed {
33830                         if err := pcall(func() {
33831                                 (((*(*(struct {
33832                                         Type NodeBoxType
33833
33834                                         //mt:if %s.Type == MountedBox
33835                                         WallTop, WallBot, WallSides Box
33836
33837                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33838                                         Fixed []Box
33839
33840                                         //mt:if %s.Type == ConnectedBox
33841                                         ConnDirs, DiscoDirs  DirBoxes
33842                                         DiscoAll, DiscoSides []Box
33843                                 }))(obj)).Fixed)[local376]).serialize(w)
33844                         }); err != nil {
33845                                 if err == io.EOF {
33846                                         chk(io.EOF)
33847                                 }
33848                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33849                         }
33850                 }
33851         }
33852         if (*(*(struct {
33853                 Type NodeBoxType
33854
33855                 //mt:if %s.Type == MountedBox
33856                 WallTop, WallBot, WallSides Box
33857
33858                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33859                 Fixed []Box
33860
33861                 //mt:if %s.Type == ConnectedBox
33862                 ConnDirs, DiscoDirs  DirBoxes
33863                 DiscoAll, DiscoSides []Box
33864         }))(obj)).Type == ConnectedBox {
33865                 if err := pcall(func() {
33866                         ((*(*(struct {
33867                                 Type NodeBoxType
33868
33869                                 //mt:if %s.Type == MountedBox
33870                                 WallTop, WallBot, WallSides Box
33871
33872                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33873                                 Fixed []Box
33874
33875                                 //mt:if %s.Type == ConnectedBox
33876                                 ConnDirs, DiscoDirs  DirBoxes
33877                                 DiscoAll, DiscoSides []Box
33878                         }))(obj)).ConnDirs).serialize(w)
33879                 }); err != nil {
33880                         if err == io.EOF {
33881                                 chk(io.EOF)
33882                         }
33883                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33884                 }
33885                 if err := pcall(func() {
33886                         ((*(*(struct {
33887                                 Type NodeBoxType
33888
33889                                 //mt:if %s.Type == MountedBox
33890                                 WallTop, WallBot, WallSides Box
33891
33892                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33893                                 Fixed []Box
33894
33895                                 //mt:if %s.Type == ConnectedBox
33896                                 ConnDirs, DiscoDirs  DirBoxes
33897                                 DiscoAll, DiscoSides []Box
33898                         }))(obj)).DiscoDirs).serialize(w)
33899                 }); err != nil {
33900                         if err == io.EOF {
33901                                 chk(io.EOF)
33902                         }
33903                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
33904                 }
33905                 if len(((*(*(struct {
33906                         Type NodeBoxType
33907
33908                         //mt:if %s.Type == MountedBox
33909                         WallTop, WallBot, WallSides Box
33910
33911                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33912                         Fixed []Box
33913
33914                         //mt:if %s.Type == ConnectedBox
33915                         ConnDirs, DiscoDirs  DirBoxes
33916                         DiscoAll, DiscoSides []Box
33917                 }))(obj)).DiscoAll)) > math.MaxUint16 {
33918                         chk(ErrTooLong)
33919                 }
33920                 {
33921                         x := uint16(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)))
33934                         write16(w, uint16(x))
33935                 }
33936                 for local377 := range (*(*(struct {
33937                         Type NodeBoxType
33938
33939                         //mt:if %s.Type == MountedBox
33940                         WallTop, WallBot, WallSides Box
33941
33942                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33943                         Fixed []Box
33944
33945                         //mt:if %s.Type == ConnectedBox
33946                         ConnDirs, DiscoDirs  DirBoxes
33947                         DiscoAll, DiscoSides []Box
33948                 }))(obj)).DiscoAll {
33949                         if err := pcall(func() {
33950                                 (((*(*(struct {
33951                                         Type NodeBoxType
33952
33953                                         //mt:if %s.Type == MountedBox
33954                                         WallTop, WallBot, WallSides Box
33955
33956                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33957                                         Fixed []Box
33958
33959                                         //mt:if %s.Type == ConnectedBox
33960                                         ConnDirs, DiscoDirs  DirBoxes
33961                                         DiscoAll, DiscoSides []Box
33962                                 }))(obj)).DiscoAll)[local377]).serialize(w)
33963                         }); err != nil {
33964                                 if err == io.EOF {
33965                                         chk(io.EOF)
33966                                 }
33967                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
33968                         }
33969                 }
33970                 if len(((*(*(struct {
33971                         Type NodeBoxType
33972
33973                         //mt:if %s.Type == MountedBox
33974                         WallTop, WallBot, WallSides Box
33975
33976                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
33977                         Fixed []Box
33978
33979                         //mt:if %s.Type == ConnectedBox
33980                         ConnDirs, DiscoDirs  DirBoxes
33981                         DiscoAll, DiscoSides []Box
33982                 }))(obj)).DiscoSides)) > math.MaxUint16 {
33983                         chk(ErrTooLong)
33984                 }
33985                 {
33986                         x := uint16(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)))
33999                         write16(w, uint16(x))
34000                 }
34001                 for local378 := range (*(*(struct {
34002                         Type NodeBoxType
34003
34004                         //mt:if %s.Type == MountedBox
34005                         WallTop, WallBot, WallSides Box
34006
34007                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34008                         Fixed []Box
34009
34010                         //mt:if %s.Type == ConnectedBox
34011                         ConnDirs, DiscoDirs  DirBoxes
34012                         DiscoAll, DiscoSides []Box
34013                 }))(obj)).DiscoSides {
34014                         if err := pcall(func() {
34015                                 (((*(*(struct {
34016                                         Type NodeBoxType
34017
34018                                         //mt:if %s.Type == MountedBox
34019                                         WallTop, WallBot, WallSides Box
34020
34021                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34022                                         Fixed []Box
34023
34024                                         //mt:if %s.Type == ConnectedBox
34025                                         ConnDirs, DiscoDirs  DirBoxes
34026                                         DiscoAll, DiscoSides []Box
34027                                 }))(obj)).DiscoSides)[local378]).serialize(w)
34028                         }); err != nil {
34029                                 if err == io.EOF {
34030                                         chk(io.EOF)
34031                                 }
34032                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34033                         }
34034                 }
34035         }
34036 }
34037
34038 func (obj *NodeBox) deserialize(r io.Reader) {
34039         {
34040                 var local379 uint8
34041                 local380 := uint8(6)
34042                 {
34043                         p := &local379
34044                         *p = read8(r)
34045                 }
34046                 if local379 != local380 {
34047                         chk(fmt.Errorf("const %v: %v", "uint8(6)", local379))
34048                 }
34049         }
34050         if err := pcall(func() {
34051                 ((*(*(struct {
34052                         Type NodeBoxType
34053
34054                         //mt:if %s.Type == MountedBox
34055                         WallTop, WallBot, WallSides Box
34056
34057                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34058                         Fixed []Box
34059
34060                         //mt:if %s.Type == ConnectedBox
34061                         ConnDirs, DiscoDirs  DirBoxes
34062                         DiscoAll, DiscoSides []Box
34063                 }))(obj)).Type).deserialize(r)
34064         }); err != nil {
34065                 if err == io.EOF {
34066                         chk(io.EOF)
34067                 }
34068                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.NodeBoxType", err))
34069         }
34070         if !((*(*(struct {
34071                 Type NodeBoxType
34072
34073                 //mt:if %s.Type == MountedBox
34074                 WallTop, WallBot, WallSides Box
34075
34076                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34077                 Fixed []Box
34078
34079                 //mt:if %s.Type == ConnectedBox
34080                 ConnDirs, DiscoDirs  DirBoxes
34081                 DiscoAll, DiscoSides []Box
34082         }))(obj)).Type < maxBox) {
34083                 chk(errors.New("assertion failed: %s.Type < maxBox"))
34084         }
34085         if (*(*(struct {
34086                 Type NodeBoxType
34087
34088                 //mt:if %s.Type == MountedBox
34089                 WallTop, WallBot, WallSides Box
34090
34091                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34092                 Fixed []Box
34093
34094                 //mt:if %s.Type == ConnectedBox
34095                 ConnDirs, DiscoDirs  DirBoxes
34096                 DiscoAll, DiscoSides []Box
34097         }))(obj)).Type == MountedBox {
34098                 if err := pcall(func() {
34099                         ((*(*(struct {
34100                                 Type NodeBoxType
34101
34102                                 //mt:if %s.Type == MountedBox
34103                                 WallTop, WallBot, WallSides Box
34104
34105                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34106                                 Fixed []Box
34107
34108                                 //mt:if %s.Type == ConnectedBox
34109                                 ConnDirs, DiscoDirs  DirBoxes
34110                                 DiscoAll, DiscoSides []Box
34111                         }))(obj)).WallTop).deserialize(r)
34112                 }); err != nil {
34113                         if err == io.EOF {
34114                                 chk(io.EOF)
34115                         }
34116                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34117                 }
34118                 if err := pcall(func() {
34119                         ((*(*(struct {
34120                                 Type NodeBoxType
34121
34122                                 //mt:if %s.Type == MountedBox
34123                                 WallTop, WallBot, WallSides Box
34124
34125                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34126                                 Fixed []Box
34127
34128                                 //mt:if %s.Type == ConnectedBox
34129                                 ConnDirs, DiscoDirs  DirBoxes
34130                                 DiscoAll, DiscoSides []Box
34131                         }))(obj)).WallBot).deserialize(r)
34132                 }); err != nil {
34133                         if err == io.EOF {
34134                                 chk(io.EOF)
34135                         }
34136                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34137                 }
34138                 if err := pcall(func() {
34139                         ((*(*(struct {
34140                                 Type NodeBoxType
34141
34142                                 //mt:if %s.Type == MountedBox
34143                                 WallTop, WallBot, WallSides Box
34144
34145                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34146                                 Fixed []Box
34147
34148                                 //mt:if %s.Type == ConnectedBox
34149                                 ConnDirs, DiscoDirs  DirBoxes
34150                                 DiscoAll, DiscoSides []Box
34151                         }))(obj)).WallSides).deserialize(r)
34152                 }); err != nil {
34153                         if err == io.EOF {
34154                                 chk(io.EOF)
34155                         }
34156                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34157                 }
34158         }
34159         if t := (*(*(struct {
34160                 Type NodeBoxType
34161
34162                 //mt:if %s.Type == MountedBox
34163                 WallTop, WallBot, WallSides Box
34164
34165                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34166                 Fixed []Box
34167
34168                 //mt:if %s.Type == ConnectedBox
34169                 ConnDirs, DiscoDirs  DirBoxes
34170                 DiscoAll, DiscoSides []Box
34171         }))(obj)).Type; t == FixedBox || t == LeveledBox || t == ConnectedBox {
34172                 var local381 uint16
34173                 {
34174                         p := &local381
34175                         *p = read16(r)
34176                 }
34177                 ((*(*(struct {
34178                         Type NodeBoxType
34179
34180                         //mt:if %s.Type == MountedBox
34181                         WallTop, WallBot, WallSides Box
34182
34183                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34184                         Fixed []Box
34185
34186                         //mt:if %s.Type == ConnectedBox
34187                         ConnDirs, DiscoDirs  DirBoxes
34188                         DiscoAll, DiscoSides []Box
34189                 }))(obj)).Fixed) = make([]Box, local381)
34190                 for local382 := range (*(*(struct {
34191                         Type NodeBoxType
34192
34193                         //mt:if %s.Type == MountedBox
34194                         WallTop, WallBot, WallSides Box
34195
34196                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34197                         Fixed []Box
34198
34199                         //mt:if %s.Type == ConnectedBox
34200                         ConnDirs, DiscoDirs  DirBoxes
34201                         DiscoAll, DiscoSides []Box
34202                 }))(obj)).Fixed {
34203                         if err := pcall(func() {
34204                                 (((*(*(struct {
34205                                         Type NodeBoxType
34206
34207                                         //mt:if %s.Type == MountedBox
34208                                         WallTop, WallBot, WallSides Box
34209
34210                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34211                                         Fixed []Box
34212
34213                                         //mt:if %s.Type == ConnectedBox
34214                                         ConnDirs, DiscoDirs  DirBoxes
34215                                         DiscoAll, DiscoSides []Box
34216                                 }))(obj)).Fixed)[local382]).deserialize(r)
34217                         }); err != nil {
34218                                 if err == io.EOF {
34219                                         chk(io.EOF)
34220                                 }
34221                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34222                         }
34223                 }
34224         }
34225         if (*(*(struct {
34226                 Type NodeBoxType
34227
34228                 //mt:if %s.Type == MountedBox
34229                 WallTop, WallBot, WallSides Box
34230
34231                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34232                 Fixed []Box
34233
34234                 //mt:if %s.Type == ConnectedBox
34235                 ConnDirs, DiscoDirs  DirBoxes
34236                 DiscoAll, DiscoSides []Box
34237         }))(obj)).Type == ConnectedBox {
34238                 if err := pcall(func() {
34239                         ((*(*(struct {
34240                                 Type NodeBoxType
34241
34242                                 //mt:if %s.Type == MountedBox
34243                                 WallTop, WallBot, WallSides Box
34244
34245                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34246                                 Fixed []Box
34247
34248                                 //mt:if %s.Type == ConnectedBox
34249                                 ConnDirs, DiscoDirs  DirBoxes
34250                                 DiscoAll, DiscoSides []Box
34251                         }))(obj)).ConnDirs).deserialize(r)
34252                 }); err != nil {
34253                         if err == io.EOF {
34254                                 chk(io.EOF)
34255                         }
34256                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
34257                 }
34258                 if err := pcall(func() {
34259                         ((*(*(struct {
34260                                 Type NodeBoxType
34261
34262                                 //mt:if %s.Type == MountedBox
34263                                 WallTop, WallBot, WallSides Box
34264
34265                                 //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34266                                 Fixed []Box
34267
34268                                 //mt:if %s.Type == ConnectedBox
34269                                 ConnDirs, DiscoDirs  DirBoxes
34270                                 DiscoAll, DiscoSides []Box
34271                         }))(obj)).DiscoDirs).deserialize(r)
34272                 }); err != nil {
34273                         if err == io.EOF {
34274                                 chk(io.EOF)
34275                         }
34276                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DirBoxes", err))
34277                 }
34278                 var local383 uint16
34279                 {
34280                         p := &local383
34281                         *p = read16(r)
34282                 }
34283                 ((*(*(struct {
34284                         Type NodeBoxType
34285
34286                         //mt:if %s.Type == MountedBox
34287                         WallTop, WallBot, WallSides Box
34288
34289                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34290                         Fixed []Box
34291
34292                         //mt:if %s.Type == ConnectedBox
34293                         ConnDirs, DiscoDirs  DirBoxes
34294                         DiscoAll, DiscoSides []Box
34295                 }))(obj)).DiscoAll) = make([]Box, local383)
34296                 for local384 := range (*(*(struct {
34297                         Type NodeBoxType
34298
34299                         //mt:if %s.Type == MountedBox
34300                         WallTop, WallBot, WallSides Box
34301
34302                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34303                         Fixed []Box
34304
34305                         //mt:if %s.Type == ConnectedBox
34306                         ConnDirs, DiscoDirs  DirBoxes
34307                         DiscoAll, DiscoSides []Box
34308                 }))(obj)).DiscoAll {
34309                         if err := pcall(func() {
34310                                 (((*(*(struct {
34311                                         Type NodeBoxType
34312
34313                                         //mt:if %s.Type == MountedBox
34314                                         WallTop, WallBot, WallSides Box
34315
34316                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34317                                         Fixed []Box
34318
34319                                         //mt:if %s.Type == ConnectedBox
34320                                         ConnDirs, DiscoDirs  DirBoxes
34321                                         DiscoAll, DiscoSides []Box
34322                                 }))(obj)).DiscoAll)[local384]).deserialize(r)
34323                         }); err != nil {
34324                                 if err == io.EOF {
34325                                         chk(io.EOF)
34326                                 }
34327                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34328                         }
34329                 }
34330                 var local385 uint16
34331                 {
34332                         p := &local385
34333                         *p = read16(r)
34334                 }
34335                 ((*(*(struct {
34336                         Type NodeBoxType
34337
34338                         //mt:if %s.Type == MountedBox
34339                         WallTop, WallBot, WallSides Box
34340
34341                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34342                         Fixed []Box
34343
34344                         //mt:if %s.Type == ConnectedBox
34345                         ConnDirs, DiscoDirs  DirBoxes
34346                         DiscoAll, DiscoSides []Box
34347                 }))(obj)).DiscoSides) = make([]Box, local385)
34348                 for local386 := range (*(*(struct {
34349                         Type NodeBoxType
34350
34351                         //mt:if %s.Type == MountedBox
34352                         WallTop, WallBot, WallSides Box
34353
34354                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34355                         Fixed []Box
34356
34357                         //mt:if %s.Type == ConnectedBox
34358                         ConnDirs, DiscoDirs  DirBoxes
34359                         DiscoAll, DiscoSides []Box
34360                 }))(obj)).DiscoSides {
34361                         if err := pcall(func() {
34362                                 (((*(*(struct {
34363                                         Type NodeBoxType
34364
34365                                         //mt:if %s.Type == MountedBox
34366                                         WallTop, WallBot, WallSides Box
34367
34368                                         //mt:if t := %s.Type; t == FixedBox || t == LeveledBox || t == ConnectedBox
34369                                         Fixed []Box
34370
34371                                         //mt:if %s.Type == ConnectedBox
34372                                         ConnDirs, DiscoDirs  DirBoxes
34373                                         DiscoAll, DiscoSides []Box
34374                                 }))(obj)).DiscoSides)[local386]).deserialize(r)
34375                         }); err != nil {
34376                                 if err == io.EOF {
34377                                         chk(io.EOF)
34378                                 }
34379                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
34380                         }
34381                 }
34382         }
34383 }
34384
34385 func (obj *SoundDef) serialize(w io.Writer) {
34386         if len(([]byte((*(*(struct {
34387                 Name              string
34388                 Gain, Pitch, Fade float32
34389         }))(obj)).Name))) > math.MaxUint16 {
34390                 chk(ErrTooLong)
34391         }
34392         {
34393                 x := uint16(len(([]byte((*(*(struct {
34394                         Name              string
34395                         Gain, Pitch, Fade float32
34396                 }))(obj)).Name))))
34397                 write16(w, uint16(x))
34398         }
34399         {
34400                 _, err := w.Write(([]byte((*(*(struct {
34401                         Name              string
34402                         Gain, Pitch, Fade float32
34403                 }))(obj)).Name))[:])
34404                 chk(err)
34405         }
34406         {
34407                 x := (*(*(struct {
34408                         Name              string
34409                         Gain, Pitch, Fade float32
34410                 }))(obj)).Gain
34411                 write32(w, math.Float32bits(x))
34412         }
34413         {
34414                 x := (*(*(struct {
34415                         Name              string
34416                         Gain, Pitch, Fade float32
34417                 }))(obj)).Pitch
34418                 write32(w, math.Float32bits(x))
34419         }
34420         {
34421                 x := (*(*(struct {
34422                         Name              string
34423                         Gain, Pitch, Fade float32
34424                 }))(obj)).Fade
34425                 write32(w, math.Float32bits(x))
34426         }
34427 }
34428
34429 func (obj *SoundDef) deserialize(r io.Reader) {
34430         var local387 []uint8
34431         var local388 uint16
34432         {
34433                 p := &local388
34434                 *p = read16(r)
34435         }
34436         (local387) = make([]uint8, local388)
34437         {
34438                 _, err := io.ReadFull(r, (local387)[:])
34439                 chk(err)
34440         }
34441         ((*(*(struct {
34442                 Name              string
34443                 Gain, Pitch, Fade float32
34444         }))(obj)).Name) = string(local387)
34445         {
34446                 p := &(*(*(struct {
34447                         Name              string
34448                         Gain, Pitch, Fade float32
34449                 }))(obj)).Gain
34450                 *p = math.Float32frombits(read32(r))
34451         }
34452         {
34453                 p := &(*(*(struct {
34454                         Name              string
34455                         Gain, Pitch, Fade float32
34456                 }))(obj)).Pitch
34457                 *p = math.Float32frombits(read32(r))
34458         }
34459         {
34460                 p := &(*(*(struct {
34461                         Name              string
34462                         Gain, Pitch, Fade float32
34463                 }))(obj)).Fade
34464                 *p = math.Float32frombits(read32(r))
34465         }
34466 }
34467
34468 func (obj *AlphaUse) serialize(w io.Writer) {
34469         {
34470                 x := *(*(uint8))(obj)
34471                 write8(w, uint8(x))
34472         }
34473 }
34474
34475 func (obj *AlphaUse) deserialize(r io.Reader) {
34476         {
34477                 p := &*(*(uint8))(obj)
34478                 *p = read8(r)
34479         }
34480 }
34481
34482 func (obj *Keys) serialize(w io.Writer) {
34483         {
34484                 x := *(*(uint32))(obj)
34485                 write32(w, uint32(x))
34486         }
34487 }
34488
34489 func (obj *Keys) deserialize(r io.Reader) {
34490         {
34491                 p := &*(*(uint32))(obj)
34492                 *p = read32(r)
34493         }
34494 }
34495
34496 func (obj *MapBlkFlags) serialize(w io.Writer) {
34497         {
34498                 x := *(*(uint8))(obj)
34499                 write8(w, uint8(x))
34500         }
34501 }
34502
34503 func (obj *MapBlkFlags) deserialize(r io.Reader) {
34504         {
34505                 p := &*(*(uint8))(obj)
34506                 *p = read8(r)
34507         }
34508 }
34509
34510 func (obj *LitFromBlks) serialize(w io.Writer) {
34511         {
34512                 x := *(*(uint16))(obj)
34513                 write16(w, uint16(x))
34514         }
34515 }
34516
34517 func (obj *LitFromBlks) deserialize(r io.Reader) {
34518         {
34519                 p := &*(*(uint16))(obj)
34520                 *p = read16(r)
34521         }
34522 }
34523
34524 func (obj *AOInitData) serialize(w io.Writer) {
34525         {
34526                 local389 := uint8(1)
34527                 {
34528                         x := local389
34529                         write8(w, uint8(x))
34530                 }
34531         }
34532         if len(([]byte((*(*(struct {
34533
34534                 // For players.
34535                 Name     string
34536                 IsPlayer bool
34537
34538                 ID AOID
34539
34540                 Pos
34541                 Rot [3]float32
34542
34543                 HP uint16
34544
34545                 // See (de)serialize.fmt.
34546                 Msgs []AOMsg
34547         }))(obj)).Name))) > math.MaxUint16 {
34548                 chk(ErrTooLong)
34549         }
34550         {
34551                 x := uint16(len(([]byte((*(*(struct {
34552
34553                         // For players.
34554                         Name     string
34555                         IsPlayer bool
34556
34557                         ID AOID
34558
34559                         Pos
34560                         Rot [3]float32
34561
34562                         HP uint16
34563
34564                         // See (de)serialize.fmt.
34565                         Msgs []AOMsg
34566                 }))(obj)).Name))))
34567                 write16(w, uint16(x))
34568         }
34569         {
34570                 _, err := w.Write(([]byte((*(*(struct {
34571
34572                         // For players.
34573                         Name     string
34574                         IsPlayer bool
34575
34576                         ID AOID
34577
34578                         Pos
34579                         Rot [3]float32
34580
34581                         HP uint16
34582
34583                         // See (de)serialize.fmt.
34584                         Msgs []AOMsg
34585                 }))(obj)).Name))[:])
34586                 chk(err)
34587         }
34588         {
34589                 x := (*(*(struct {
34590
34591                         // For players.
34592                         Name     string
34593                         IsPlayer bool
34594
34595                         ID AOID
34596
34597                         Pos
34598                         Rot [3]float32
34599
34600                         HP uint16
34601
34602                         // See (de)serialize.fmt.
34603                         Msgs []AOMsg
34604                 }))(obj)).IsPlayer
34605                 if x {
34606                         write8(w, 1)
34607                 } else {
34608                         write8(w, 0)
34609                 }
34610         }
34611         if err := pcall(func() {
34612                 ((*(*(struct {
34613
34614                         // For players.
34615                         Name     string
34616                         IsPlayer bool
34617
34618                         ID AOID
34619
34620                         Pos
34621                         Rot [3]float32
34622
34623                         HP uint16
34624
34625                         // See (de)serialize.fmt.
34626                         Msgs []AOMsg
34627                 }))(obj)).ID).serialize(w)
34628         }); err != nil {
34629                 if err == io.EOF {
34630                         chk(io.EOF)
34631                 }
34632                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
34633         }
34634         if err := pcall(func() {
34635                 ((*(*(struct {
34636
34637                         // For players.
34638                         Name     string
34639                         IsPlayer bool
34640
34641                         ID AOID
34642
34643                         Pos
34644                         Rot [3]float32
34645
34646                         HP uint16
34647
34648                         // See (de)serialize.fmt.
34649                         Msgs []AOMsg
34650                 }))(obj)).Pos).serialize(w)
34651         }); err != nil {
34652                 if err == io.EOF {
34653                         chk(io.EOF)
34654                 }
34655                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
34656         }
34657         for local390 := range (*(*(struct {
34658
34659                 // For players.
34660                 Name     string
34661                 IsPlayer bool
34662
34663                 ID AOID
34664
34665                 Pos
34666                 Rot [3]float32
34667
34668                 HP uint16
34669
34670                 // See (de)serialize.fmt.
34671                 Msgs []AOMsg
34672         }))(obj)).Rot {
34673                 {
34674                         x := ((*(*(struct {
34675
34676                                 // For players.
34677                                 Name     string
34678                                 IsPlayer bool
34679
34680                                 ID AOID
34681
34682                                 Pos
34683                                 Rot [3]float32
34684
34685                                 HP uint16
34686
34687                                 // See (de)serialize.fmt.
34688                                 Msgs []AOMsg
34689                         }))(obj)).Rot)[local390]
34690                         write32(w, math.Float32bits(x))
34691                 }
34692         }
34693         {
34694                 x := (*(*(struct {
34695
34696                         // For players.
34697                         Name     string
34698                         IsPlayer bool
34699
34700                         ID AOID
34701
34702                         Pos
34703                         Rot [3]float32
34704
34705                         HP uint16
34706
34707                         // See (de)serialize.fmt.
34708                         Msgs []AOMsg
34709                 }))(obj)).HP
34710                 write16(w, uint16(x))
34711         }
34712         {
34713                 x := (*(*(struct {
34714
34715                         // For players.
34716                         Name     string
34717                         IsPlayer bool
34718
34719                         ID AOID
34720
34721                         Pos
34722                         Rot [3]float32
34723
34724                         HP uint16
34725
34726                         // See (de)serialize.fmt.
34727                         Msgs []AOMsg
34728                 }))(obj)).Msgs
34729                 { // For AOInitData.Msgs.
34730                         if len(x) > math.MaxUint8 {
34731                                 chk(ErrTooLong)
34732                         }
34733                         write8(w, uint8(len(x)))
34734                         for _, msg := range x {
34735                                 var b bytes.Buffer
34736                                 chk(writeAOMsg(&b, msg))
34737                                 if b.Len() > math.MaxUint32 {
34738                                         chk(ErrTooLong)
34739                                 }
34740                                 write32(w, uint32(b.Len()))
34741                                 _, err := b.WriteTo(w)
34742                                 chk(err)
34743                         }
34744                 }
34745         }
34746 }
34747
34748 func (obj *AOInitData) deserialize(r io.Reader) {
34749         {
34750                 var local391 uint8
34751                 local392 := uint8(1)
34752                 {
34753                         p := &local391
34754                         *p = read8(r)
34755                 }
34756                 if local391 != local392 {
34757                         chk(fmt.Errorf("const %v: %v", "uint8(1)", local391))
34758                 }
34759         }
34760         var local393 []uint8
34761         var local394 uint16
34762         {
34763                 p := &local394
34764                 *p = read16(r)
34765         }
34766         (local393) = make([]uint8, local394)
34767         {
34768                 _, err := io.ReadFull(r, (local393)[:])
34769                 chk(err)
34770         }
34771         ((*(*(struct {
34772
34773                 // For players.
34774                 Name     string
34775                 IsPlayer bool
34776
34777                 ID AOID
34778
34779                 Pos
34780                 Rot [3]float32
34781
34782                 HP uint16
34783
34784                 // See (de)serialize.fmt.
34785                 Msgs []AOMsg
34786         }))(obj)).Name) = string(local393)
34787         {
34788                 p := &(*(*(struct {
34789
34790                         // For players.
34791                         Name     string
34792                         IsPlayer bool
34793
34794                         ID AOID
34795
34796                         Pos
34797                         Rot [3]float32
34798
34799                         HP uint16
34800
34801                         // See (de)serialize.fmt.
34802                         Msgs []AOMsg
34803                 }))(obj)).IsPlayer
34804                 switch n := read8(r); n {
34805                 case 0:
34806                         *p = false
34807                 case 1:
34808                         *p = true
34809                 default:
34810                         chk(fmt.Errorf("invalid bool: %d", n))
34811                 }
34812         }
34813         if err := pcall(func() {
34814                 ((*(*(struct {
34815
34816                         // For players.
34817                         Name     string
34818                         IsPlayer bool
34819
34820                         ID AOID
34821
34822                         Pos
34823                         Rot [3]float32
34824
34825                         HP uint16
34826
34827                         // See (de)serialize.fmt.
34828                         Msgs []AOMsg
34829                 }))(obj)).ID).deserialize(r)
34830         }); err != nil {
34831                 if err == io.EOF {
34832                         chk(io.EOF)
34833                 }
34834                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.AOID", err))
34835         }
34836         if err := pcall(func() {
34837                 ((*(*(struct {
34838
34839                         // For players.
34840                         Name     string
34841                         IsPlayer bool
34842
34843                         ID AOID
34844
34845                         Pos
34846                         Rot [3]float32
34847
34848                         HP uint16
34849
34850                         // See (de)serialize.fmt.
34851                         Msgs []AOMsg
34852                 }))(obj)).Pos).deserialize(r)
34853         }); err != nil {
34854                 if err == io.EOF {
34855                         chk(io.EOF)
34856                 }
34857                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Pos", err))
34858         }
34859         for local395 := range (*(*(struct {
34860
34861                 // For players.
34862                 Name     string
34863                 IsPlayer bool
34864
34865                 ID AOID
34866
34867                 Pos
34868                 Rot [3]float32
34869
34870                 HP uint16
34871
34872                 // See (de)serialize.fmt.
34873                 Msgs []AOMsg
34874         }))(obj)).Rot {
34875                 {
34876                         p := &((*(*(struct {
34877
34878                                 // For players.
34879                                 Name     string
34880                                 IsPlayer bool
34881
34882                                 ID AOID
34883
34884                                 Pos
34885                                 Rot [3]float32
34886
34887                                 HP uint16
34888
34889                                 // See (de)serialize.fmt.
34890                                 Msgs []AOMsg
34891                         }))(obj)).Rot)[local395]
34892                         *p = math.Float32frombits(read32(r))
34893                 }
34894         }
34895         {
34896                 p := &(*(*(struct {
34897
34898                         // For players.
34899                         Name     string
34900                         IsPlayer bool
34901
34902                         ID AOID
34903
34904                         Pos
34905                         Rot [3]float32
34906
34907                         HP uint16
34908
34909                         // See (de)serialize.fmt.
34910                         Msgs []AOMsg
34911                 }))(obj)).HP
34912                 *p = read16(r)
34913         }
34914         {
34915                 p := &(*(*(struct {
34916
34917                         // For players.
34918                         Name     string
34919                         IsPlayer bool
34920
34921                         ID AOID
34922
34923                         Pos
34924                         Rot [3]float32
34925
34926                         HP uint16
34927
34928                         // See (de)serialize.fmt.
34929                         Msgs []AOMsg
34930                 }))(obj)).Msgs
34931                 { // For AOInitData.Msgs.
34932                         *p = make([]AOMsg, read8(r))
34933                         for i := range *p {
34934                                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
34935                                 msg, err := readAOMsg(r)
34936                                 chk(err)
34937                                 (*p)[i] = msg
34938                                 if r.N > 0 {
34939                                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
34940                                 }
34941                         }
34942                 }
34943         }
34944 }
34945
34946 func (obj *ItemType) serialize(w io.Writer) {
34947         {
34948                 x := *(*(uint8))(obj)
34949                 write8(w, uint8(x))
34950         }
34951 }
34952
34953 func (obj *ItemType) deserialize(r io.Reader) {
34954         {
34955                 p := &*(*(uint8))(obj)
34956                 *p = read8(r)
34957         }
34958 }
34959
34960 func (obj *ToolCaps) serialize(w io.Writer) {
34961         if _ = (*(*(struct {
34962                 //mt:if _ = %s; false
34963                 NonNil bool
34964
34965                 AttackCooldown float32
34966                 MaxDropLvl     int16
34967
34968                 //mt:len32
34969                 GroupCaps []ToolGroupCap
34970
34971                 //mt:len32
34972                 DmgGroups []Group
34973
34974                 //mt:32tou16
34975                 PunchUses int32
34976         }))(obj)); false {
34977                 {
34978                         x := (*(*(struct {
34979                                 //mt:if _ = %s; false
34980                                 NonNil bool
34981
34982                                 AttackCooldown float32
34983                                 MaxDropLvl     int16
34984
34985                                 //mt:len32
34986                                 GroupCaps []ToolGroupCap
34987
34988                                 //mt:len32
34989                                 DmgGroups []Group
34990
34991                                 //mt:32tou16
34992                                 PunchUses int32
34993                         }))(obj)).NonNil
34994                         if x {
34995                                 write8(w, 1)
34996                         } else {
34997                                 write8(w, 0)
34998                         }
34999                 }
35000         }
35001         {
35002                 ow := w
35003                 w := new(bytes.Buffer)
35004                 /*
35005                    if r.N > 0 { (*(*(struct {
35006                         //mt:if _ = %s; false
35007                         NonNil  bool
35008
35009                         AttackCooldown  float32
35010                         MaxDropLvl      int16
35011
35012                         //mt:len32
35013                         GroupCaps       []ToolGroupCap
35014
35015                         //mt:len32
35016                         DmgGroups       []Group
35017
35018                         //mt:32tou16
35019                         PunchUses       int32
35020                    }))(obj)).NonNil = true}; /**/{
35021                         if (*(*(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 {
35037                                 {
35038                                         local396 := uint8(5)
35039                                         {
35040                                                 x := local396
35041                                                 write8(w, uint8(x))
35042                                         }
35043                                 }
35044                                 {
35045                                         x := (*(*(struct {
35046                                                 //mt:if _ = %s; false
35047                                                 NonNil bool
35048
35049                                                 AttackCooldown float32
35050                                                 MaxDropLvl     int16
35051
35052                                                 //mt:len32
35053                                                 GroupCaps []ToolGroupCap
35054
35055                                                 //mt:len32
35056                                                 DmgGroups []Group
35057
35058                                                 //mt:32tou16
35059                                                 PunchUses int32
35060                                         }))(obj)).AttackCooldown
35061                                         write32(w, math.Float32bits(x))
35062                                 }
35063                                 {
35064                                         x := (*(*(struct {
35065                                                 //mt:if _ = %s; false
35066                                                 NonNil bool
35067
35068                                                 AttackCooldown float32
35069                                                 MaxDropLvl     int16
35070
35071                                                 //mt:len32
35072                                                 GroupCaps []ToolGroupCap
35073
35074                                                 //mt:len32
35075                                                 DmgGroups []Group
35076
35077                                                 //mt:32tou16
35078                                                 PunchUses int32
35079                                         }))(obj)).MaxDropLvl
35080                                         write16(w, uint16(x))
35081                                 }
35082                                 if len(((*(*(struct {
35083                                         //mt:if _ = %s; false
35084                                         NonNil bool
35085
35086                                         AttackCooldown float32
35087                                         MaxDropLvl     int16
35088
35089                                         //mt:len32
35090                                         GroupCaps []ToolGroupCap
35091
35092                                         //mt:len32
35093                                         DmgGroups []Group
35094
35095                                         //mt:32tou16
35096                                         PunchUses int32
35097                                 }))(obj)).GroupCaps)) > math.MaxUint32 {
35098                                         chk(ErrTooLong)
35099                                 }
35100                                 {
35101                                         x := uint32(len(((*(*(struct {
35102                                                 //mt:if _ = %s; false
35103                                                 NonNil bool
35104
35105                                                 AttackCooldown float32
35106                                                 MaxDropLvl     int16
35107
35108                                                 //mt:len32
35109                                                 GroupCaps []ToolGroupCap
35110
35111                                                 //mt:len32
35112                                                 DmgGroups []Group
35113
35114                                                 //mt:32tou16
35115                                                 PunchUses int32
35116                                         }))(obj)).GroupCaps)))
35117                                         write32(w, uint32(x))
35118                                 }
35119                                 for local397 := range (*(*(struct {
35120                                         //mt:if _ = %s; false
35121                                         NonNil bool
35122
35123                                         AttackCooldown float32
35124                                         MaxDropLvl     int16
35125
35126                                         //mt:len32
35127                                         GroupCaps []ToolGroupCap
35128
35129                                         //mt:len32
35130                                         DmgGroups []Group
35131
35132                                         //mt:32tou16
35133                                         PunchUses int32
35134                                 }))(obj)).GroupCaps {
35135                                         if err := pcall(func() {
35136                                                 (((*(*(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)[local397]).serialize(w)
35152                                         }); err != nil {
35153                                                 if err == io.EOF {
35154                                                         chk(io.EOF)
35155                                                 }
35156                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
35157                                         }
35158                                 }
35159                                 if len(((*(*(struct {
35160                                         //mt:if _ = %s; false
35161                                         NonNil bool
35162
35163                                         AttackCooldown float32
35164                                         MaxDropLvl     int16
35165
35166                                         //mt:len32
35167                                         GroupCaps []ToolGroupCap
35168
35169                                         //mt:len32
35170                                         DmgGroups []Group
35171
35172                                         //mt:32tou16
35173                                         PunchUses int32
35174                                 }))(obj)).DmgGroups)) > math.MaxUint32 {
35175                                         chk(ErrTooLong)
35176                                 }
35177                                 {
35178                                         x := uint32(len(((*(*(struct {
35179                                                 //mt:if _ = %s; false
35180                                                 NonNil bool
35181
35182                                                 AttackCooldown float32
35183                                                 MaxDropLvl     int16
35184
35185                                                 //mt:len32
35186                                                 GroupCaps []ToolGroupCap
35187
35188                                                 //mt:len32
35189                                                 DmgGroups []Group
35190
35191                                                 //mt:32tou16
35192                                                 PunchUses int32
35193                                         }))(obj)).DmgGroups)))
35194                                         write32(w, uint32(x))
35195                                 }
35196                                 for local398 := range (*(*(struct {
35197                                         //mt:if _ = %s; false
35198                                         NonNil bool
35199
35200                                         AttackCooldown float32
35201                                         MaxDropLvl     int16
35202
35203                                         //mt:len32
35204                                         GroupCaps []ToolGroupCap
35205
35206                                         //mt:len32
35207                                         DmgGroups []Group
35208
35209                                         //mt:32tou16
35210                                         PunchUses int32
35211                                 }))(obj)).DmgGroups {
35212                                         if err := pcall(func() {
35213                                                 (((*(*(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)[local398]).serialize(w)
35229                                         }); err != nil {
35230                                                 if err == io.EOF {
35231                                                         chk(io.EOF)
35232                                                 }
35233                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
35234                                         }
35235                                 }
35236                                 {
35237                                         x := uint16((*(*(struct {
35238                                                 //mt:if _ = %s; false
35239                                                 NonNil bool
35240
35241                                                 AttackCooldown float32
35242                                                 MaxDropLvl     int16
35243
35244                                                 //mt:len32
35245                                                 GroupCaps []ToolGroupCap
35246
35247                                                 //mt:len32
35248                                                 DmgGroups []Group
35249
35250                                                 //mt:32tou16
35251                                                 PunchUses int32
35252                                         }))(obj)).PunchUses)
35253                                         write16(w, uint16(x))
35254                                 }
35255                         }
35256                 }
35257                 {
35258                         buf := w
35259                         w := ow
35260                         if len((buf.Bytes())) > math.MaxUint16 {
35261                                 chk(ErrTooLong)
35262                         }
35263                         {
35264                                 x := uint16(len((buf.Bytes())))
35265                                 write16(w, uint16(x))
35266                         }
35267                         {
35268                                 _, err := w.Write((buf.Bytes())[:])
35269                                 chk(err)
35270                         }
35271                 }
35272         }
35273 }
35274
35275 func (obj *ToolCaps) deserialize(r io.Reader) {
35276         if _ = (*(*(struct {
35277                 //mt:if _ = %s; false
35278                 NonNil bool
35279
35280                 AttackCooldown float32
35281                 MaxDropLvl     int16
35282
35283                 //mt:len32
35284                 GroupCaps []ToolGroupCap
35285
35286                 //mt:len32
35287                 DmgGroups []Group
35288
35289                 //mt:32tou16
35290                 PunchUses int32
35291         }))(obj)); false {
35292                 {
35293                         p := &(*(*(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)).NonNil
35309                         switch n := read8(r); n {
35310                         case 0:
35311                                 *p = false
35312                         case 1:
35313                                 *p = true
35314                         default:
35315                                 chk(fmt.Errorf("invalid bool: %d", n))
35316                         }
35317                 }
35318         }
35319         {
35320                 var n uint16
35321                 {
35322                         p := &n
35323                         *p = read16(r)
35324                 }
35325                 r := &io.LimitedReader{R: r, N: int64(n)}
35326                 if r.N > 0 {
35327                         (*(*(struct {
35328                                 //mt:if _ = %s; false
35329                                 NonNil bool
35330
35331                                 AttackCooldown float32
35332                                 MaxDropLvl     int16
35333
35334                                 //mt:len32
35335                                 GroupCaps []ToolGroupCap
35336
35337                                 //mt:len32
35338                                 DmgGroups []Group
35339
35340                                 //mt:32tou16
35341                                 PunchUses int32
35342                         }))(obj)).NonNil = true
35343                 } /**/
35344                 {
35345                         if (*(*(struct {
35346                                 //mt:if _ = %s; false
35347                                 NonNil bool
35348
35349                                 AttackCooldown float32
35350                                 MaxDropLvl     int16
35351
35352                                 //mt:len32
35353                                 GroupCaps []ToolGroupCap
35354
35355                                 //mt:len32
35356                                 DmgGroups []Group
35357
35358                                 //mt:32tou16
35359                                 PunchUses int32
35360                         }))(obj)).NonNil {
35361                                 {
35362                                         var local399 uint8
35363                                         local400 := uint8(5)
35364                                         {
35365                                                 p := &local399
35366                                                 *p = read8(r)
35367                                         }
35368                                         if local399 != local400 {
35369                                                 chk(fmt.Errorf("const %v: %v", "uint8(5)", local399))
35370                                         }
35371                                 }
35372                                 {
35373                                         p := &(*(*(struct {
35374                                                 //mt:if _ = %s; false
35375                                                 NonNil bool
35376
35377                                                 AttackCooldown float32
35378                                                 MaxDropLvl     int16
35379
35380                                                 //mt:len32
35381                                                 GroupCaps []ToolGroupCap
35382
35383                                                 //mt:len32
35384                                                 DmgGroups []Group
35385
35386                                                 //mt:32tou16
35387                                                 PunchUses int32
35388                                         }))(obj)).AttackCooldown
35389                                         *p = math.Float32frombits(read32(r))
35390                                 }
35391                                 {
35392                                         p := &(*(*(struct {
35393                                                 //mt:if _ = %s; false
35394                                                 NonNil bool
35395
35396                                                 AttackCooldown float32
35397                                                 MaxDropLvl     int16
35398
35399                                                 //mt:len32
35400                                                 GroupCaps []ToolGroupCap
35401
35402                                                 //mt:len32
35403                                                 DmgGroups []Group
35404
35405                                                 //mt:32tou16
35406                                                 PunchUses int32
35407                                         }))(obj)).MaxDropLvl
35408                                         *p = int16(read16(r))
35409                                 }
35410                                 var local401 uint32
35411                                 {
35412                                         p := &local401
35413                                         *p = read32(r)
35414                                 }
35415                                 ((*(*(struct {
35416                                         //mt:if _ = %s; false
35417                                         NonNil bool
35418
35419                                         AttackCooldown float32
35420                                         MaxDropLvl     int16
35421
35422                                         //mt:len32
35423                                         GroupCaps []ToolGroupCap
35424
35425                                         //mt:len32
35426                                         DmgGroups []Group
35427
35428                                         //mt:32tou16
35429                                         PunchUses int32
35430                                 }))(obj)).GroupCaps) = make([]ToolGroupCap, local401)
35431                                 for local402 := range (*(*(struct {
35432                                         //mt:if _ = %s; false
35433                                         NonNil bool
35434
35435                                         AttackCooldown float32
35436                                         MaxDropLvl     int16
35437
35438                                         //mt:len32
35439                                         GroupCaps []ToolGroupCap
35440
35441                                         //mt:len32
35442                                         DmgGroups []Group
35443
35444                                         //mt:32tou16
35445                                         PunchUses int32
35446                                 }))(obj)).GroupCaps {
35447                                         if err := pcall(func() {
35448                                                 (((*(*(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)[local402]).deserialize(r)
35464                                         }); err != nil {
35465                                                 if err == io.EOF {
35466                                                         chk(io.EOF)
35467                                                 }
35468                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.ToolGroupCap", err))
35469                                         }
35470                                 }
35471                                 var local403 uint32
35472                                 {
35473                                         p := &local403
35474                                         *p = read32(r)
35475                                 }
35476                                 ((*(*(struct {
35477                                         //mt:if _ = %s; false
35478                                         NonNil bool
35479
35480                                         AttackCooldown float32
35481                                         MaxDropLvl     int16
35482
35483                                         //mt:len32
35484                                         GroupCaps []ToolGroupCap
35485
35486                                         //mt:len32
35487                                         DmgGroups []Group
35488
35489                                         //mt:32tou16
35490                                         PunchUses int32
35491                                 }))(obj)).DmgGroups) = make([]Group, local403)
35492                                 for local404 := range (*(*(struct {
35493                                         //mt:if _ = %s; false
35494                                         NonNil bool
35495
35496                                         AttackCooldown float32
35497                                         MaxDropLvl     int16
35498
35499                                         //mt:len32
35500                                         GroupCaps []ToolGroupCap
35501
35502                                         //mt:len32
35503                                         DmgGroups []Group
35504
35505                                         //mt:32tou16
35506                                         PunchUses int32
35507                                 }))(obj)).DmgGroups {
35508                                         if err := pcall(func() {
35509                                                 (((*(*(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)[local404]).deserialize(r)
35525                                         }); err != nil {
35526                                                 if err == io.EOF {
35527                                                         chk(io.EOF)
35528                                                 }
35529                                                 chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Group", err))
35530                                         }
35531                                 }
35532                                 var local405 uint16
35533                                 {
35534                                         p := &local405
35535                                         *p = read16(r)
35536                                 }
35537                                 (*(*(struct {
35538                                         //mt:if _ = %s; false
35539                                         NonNil bool
35540
35541                                         AttackCooldown float32
35542                                         MaxDropLvl     int16
35543
35544                                         //mt:len32
35545                                         GroupCaps []ToolGroupCap
35546
35547                                         //mt:len32
35548                                         DmgGroups []Group
35549
35550                                         //mt:32tou16
35551                                         PunchUses int32
35552                                 }))(obj)).PunchUses = int32(local405)
35553                         }
35554                 }
35555                 if r.N > 0 {
35556                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
35557                 }
35558         }
35559 }
35560
35561 func (obj *AnimType) serialize(w io.Writer) {
35562         {
35563                 x := *(*(uint8))(obj)
35564                 write8(w, uint8(x))
35565         }
35566 }
35567
35568 func (obj *AnimType) deserialize(r io.Reader) {
35569         {
35570                 p := &*(*(uint8))(obj)
35571                 *p = read8(r)
35572         }
35573 }
35574
35575 func (obj *HUDType) serialize(w io.Writer) {
35576         {
35577                 x := *(*(uint8))(obj)
35578                 write8(w, uint8(x))
35579         }
35580 }
35581
35582 func (obj *HUDType) deserialize(r io.Reader) {
35583         {
35584                 p := &*(*(uint8))(obj)
35585                 *p = read8(r)
35586         }
35587 }
35588
35589 func (obj *Box) serialize(w io.Writer) {
35590         for local406 := range *(*([2]Vec))(obj) {
35591                 if err := pcall(func() {
35592                         ((*(*([2]Vec))(obj))[local406]).serialize(w)
35593                 }); err != nil {
35594                         if err == io.EOF {
35595                                 chk(io.EOF)
35596                         }
35597                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
35598                 }
35599         }
35600 }
35601
35602 func (obj *Box) deserialize(r io.Reader) {
35603         for local407 := range *(*([2]Vec))(obj) {
35604                 if err := pcall(func() {
35605                         ((*(*([2]Vec))(obj))[local407]).deserialize(r)
35606                 }); err != nil {
35607                         if err == io.EOF {
35608                                 chk(io.EOF)
35609                         }
35610                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Vec", err))
35611                 }
35612         }
35613 }
35614
35615 func (obj *TileFlags) serialize(w io.Writer) {
35616         {
35617                 x := *(*(uint16))(obj)
35618                 write16(w, uint16(x))
35619         }
35620 }
35621
35622 func (obj *TileFlags) deserialize(r io.Reader) {
35623         {
35624                 p := &*(*(uint16))(obj)
35625                 *p = read16(r)
35626         }
35627 }
35628
35629 func (obj *AlignType) serialize(w io.Writer) {
35630         {
35631                 x := *(*(uint8))(obj)
35632                 write8(w, uint8(x))
35633         }
35634 }
35635
35636 func (obj *AlignType) deserialize(r io.Reader) {
35637         {
35638                 p := &*(*(uint8))(obj)
35639                 *p = read8(r)
35640         }
35641 }
35642
35643 func (obj *NodeBoxType) serialize(w io.Writer) {
35644         {
35645                 x := *(*(uint8))(obj)
35646                 write8(w, uint8(x))
35647         }
35648 }
35649
35650 func (obj *NodeBoxType) deserialize(r io.Reader) {
35651         {
35652                 p := &*(*(uint8))(obj)
35653                 *p = read8(r)
35654         }
35655 }
35656
35657 func (obj *DirBoxes) serialize(w io.Writer) {
35658         if len(((*(*(struct {
35659                 Top, Bot                 []Box
35660                 Front, Left, Back, Right []Box
35661         }))(obj)).Top)) > math.MaxUint16 {
35662                 chk(ErrTooLong)
35663         }
35664         {
35665                 x := uint16(len(((*(*(struct {
35666                         Top, Bot                 []Box
35667                         Front, Left, Back, Right []Box
35668                 }))(obj)).Top)))
35669                 write16(w, uint16(x))
35670         }
35671         for local408 := range (*(*(struct {
35672                 Top, Bot                 []Box
35673                 Front, Left, Back, Right []Box
35674         }))(obj)).Top {
35675                 if err := pcall(func() {
35676                         (((*(*(struct {
35677                                 Top, Bot                 []Box
35678                                 Front, Left, Back, Right []Box
35679                         }))(obj)).Top)[local408]).serialize(w)
35680                 }); err != nil {
35681                         if err == io.EOF {
35682                                 chk(io.EOF)
35683                         }
35684                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35685                 }
35686         }
35687         if len(((*(*(struct {
35688                 Top, Bot                 []Box
35689                 Front, Left, Back, Right []Box
35690         }))(obj)).Bot)) > math.MaxUint16 {
35691                 chk(ErrTooLong)
35692         }
35693         {
35694                 x := uint16(len(((*(*(struct {
35695                         Top, Bot                 []Box
35696                         Front, Left, Back, Right []Box
35697                 }))(obj)).Bot)))
35698                 write16(w, uint16(x))
35699         }
35700         for local409 := range (*(*(struct {
35701                 Top, Bot                 []Box
35702                 Front, Left, Back, Right []Box
35703         }))(obj)).Bot {
35704                 if err := pcall(func() {
35705                         (((*(*(struct {
35706                                 Top, Bot                 []Box
35707                                 Front, Left, Back, Right []Box
35708                         }))(obj)).Bot)[local409]).serialize(w)
35709                 }); err != nil {
35710                         if err == io.EOF {
35711                                 chk(io.EOF)
35712                         }
35713                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35714                 }
35715         }
35716         if len(((*(*(struct {
35717                 Top, Bot                 []Box
35718                 Front, Left, Back, Right []Box
35719         }))(obj)).Front)) > math.MaxUint16 {
35720                 chk(ErrTooLong)
35721         }
35722         {
35723                 x := uint16(len(((*(*(struct {
35724                         Top, Bot                 []Box
35725                         Front, Left, Back, Right []Box
35726                 }))(obj)).Front)))
35727                 write16(w, uint16(x))
35728         }
35729         for local410 := range (*(*(struct {
35730                 Top, Bot                 []Box
35731                 Front, Left, Back, Right []Box
35732         }))(obj)).Front {
35733                 if err := pcall(func() {
35734                         (((*(*(struct {
35735                                 Top, Bot                 []Box
35736                                 Front, Left, Back, Right []Box
35737                         }))(obj)).Front)[local410]).serialize(w)
35738                 }); err != nil {
35739                         if err == io.EOF {
35740                                 chk(io.EOF)
35741                         }
35742                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35743                 }
35744         }
35745         if len(((*(*(struct {
35746                 Top, Bot                 []Box
35747                 Front, Left, Back, Right []Box
35748         }))(obj)).Left)) > math.MaxUint16 {
35749                 chk(ErrTooLong)
35750         }
35751         {
35752                 x := uint16(len(((*(*(struct {
35753                         Top, Bot                 []Box
35754                         Front, Left, Back, Right []Box
35755                 }))(obj)).Left)))
35756                 write16(w, uint16(x))
35757         }
35758         for local411 := range (*(*(struct {
35759                 Top, Bot                 []Box
35760                 Front, Left, Back, Right []Box
35761         }))(obj)).Left {
35762                 if err := pcall(func() {
35763                         (((*(*(struct {
35764                                 Top, Bot                 []Box
35765                                 Front, Left, Back, Right []Box
35766                         }))(obj)).Left)[local411]).serialize(w)
35767                 }); err != nil {
35768                         if err == io.EOF {
35769                                 chk(io.EOF)
35770                         }
35771                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35772                 }
35773         }
35774         if len(((*(*(struct {
35775                 Top, Bot                 []Box
35776                 Front, Left, Back, Right []Box
35777         }))(obj)).Back)) > math.MaxUint16 {
35778                 chk(ErrTooLong)
35779         }
35780         {
35781                 x := uint16(len(((*(*(struct {
35782                         Top, Bot                 []Box
35783                         Front, Left, Back, Right []Box
35784                 }))(obj)).Back)))
35785                 write16(w, uint16(x))
35786         }
35787         for local412 := range (*(*(struct {
35788                 Top, Bot                 []Box
35789                 Front, Left, Back, Right []Box
35790         }))(obj)).Back {
35791                 if err := pcall(func() {
35792                         (((*(*(struct {
35793                                 Top, Bot                 []Box
35794                                 Front, Left, Back, Right []Box
35795                         }))(obj)).Back)[local412]).serialize(w)
35796                 }); err != nil {
35797                         if err == io.EOF {
35798                                 chk(io.EOF)
35799                         }
35800                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35801                 }
35802         }
35803         if len(((*(*(struct {
35804                 Top, Bot                 []Box
35805                 Front, Left, Back, Right []Box
35806         }))(obj)).Right)) > math.MaxUint16 {
35807                 chk(ErrTooLong)
35808         }
35809         {
35810                 x := uint16(len(((*(*(struct {
35811                         Top, Bot                 []Box
35812                         Front, Left, Back, Right []Box
35813                 }))(obj)).Right)))
35814                 write16(w, uint16(x))
35815         }
35816         for local413 := range (*(*(struct {
35817                 Top, Bot                 []Box
35818                 Front, Left, Back, Right []Box
35819         }))(obj)).Right {
35820                 if err := pcall(func() {
35821                         (((*(*(struct {
35822                                 Top, Bot                 []Box
35823                                 Front, Left, Back, Right []Box
35824                         }))(obj)).Right)[local413]).serialize(w)
35825                 }); err != nil {
35826                         if err == io.EOF {
35827                                 chk(io.EOF)
35828                         }
35829                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35830                 }
35831         }
35832 }
35833
35834 func (obj *DirBoxes) deserialize(r io.Reader) {
35835         var local414 uint16
35836         {
35837                 p := &local414
35838                 *p = read16(r)
35839         }
35840         ((*(*(struct {
35841                 Top, Bot                 []Box
35842                 Front, Left, Back, Right []Box
35843         }))(obj)).Top) = make([]Box, local414)
35844         for local415 := range (*(*(struct {
35845                 Top, Bot                 []Box
35846                 Front, Left, Back, Right []Box
35847         }))(obj)).Top {
35848                 if err := pcall(func() {
35849                         (((*(*(struct {
35850                                 Top, Bot                 []Box
35851                                 Front, Left, Back, Right []Box
35852                         }))(obj)).Top)[local415]).deserialize(r)
35853                 }); err != nil {
35854                         if err == io.EOF {
35855                                 chk(io.EOF)
35856                         }
35857                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35858                 }
35859         }
35860         var local416 uint16
35861         {
35862                 p := &local416
35863                 *p = read16(r)
35864         }
35865         ((*(*(struct {
35866                 Top, Bot                 []Box
35867                 Front, Left, Back, Right []Box
35868         }))(obj)).Bot) = make([]Box, local416)
35869         for local417 := range (*(*(struct {
35870                 Top, Bot                 []Box
35871                 Front, Left, Back, Right []Box
35872         }))(obj)).Bot {
35873                 if err := pcall(func() {
35874                         (((*(*(struct {
35875                                 Top, Bot                 []Box
35876                                 Front, Left, Back, Right []Box
35877                         }))(obj)).Bot)[local417]).deserialize(r)
35878                 }); err != nil {
35879                         if err == io.EOF {
35880                                 chk(io.EOF)
35881                         }
35882                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35883                 }
35884         }
35885         var local418 uint16
35886         {
35887                 p := &local418
35888                 *p = read16(r)
35889         }
35890         ((*(*(struct {
35891                 Top, Bot                 []Box
35892                 Front, Left, Back, Right []Box
35893         }))(obj)).Front) = make([]Box, local418)
35894         for local419 := range (*(*(struct {
35895                 Top, Bot                 []Box
35896                 Front, Left, Back, Right []Box
35897         }))(obj)).Front {
35898                 if err := pcall(func() {
35899                         (((*(*(struct {
35900                                 Top, Bot                 []Box
35901                                 Front, Left, Back, Right []Box
35902                         }))(obj)).Front)[local419]).deserialize(r)
35903                 }); err != nil {
35904                         if err == io.EOF {
35905                                 chk(io.EOF)
35906                         }
35907                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35908                 }
35909         }
35910         var local420 uint16
35911         {
35912                 p := &local420
35913                 *p = read16(r)
35914         }
35915         ((*(*(struct {
35916                 Top, Bot                 []Box
35917                 Front, Left, Back, Right []Box
35918         }))(obj)).Left) = make([]Box, local420)
35919         for local421 := range (*(*(struct {
35920                 Top, Bot                 []Box
35921                 Front, Left, Back, Right []Box
35922         }))(obj)).Left {
35923                 if err := pcall(func() {
35924                         (((*(*(struct {
35925                                 Top, Bot                 []Box
35926                                 Front, Left, Back, Right []Box
35927                         }))(obj)).Left)[local421]).deserialize(r)
35928                 }); err != nil {
35929                         if err == io.EOF {
35930                                 chk(io.EOF)
35931                         }
35932                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35933                 }
35934         }
35935         var local422 uint16
35936         {
35937                 p := &local422
35938                 *p = read16(r)
35939         }
35940         ((*(*(struct {
35941                 Top, Bot                 []Box
35942                 Front, Left, Back, Right []Box
35943         }))(obj)).Back) = make([]Box, local422)
35944         for local423 := range (*(*(struct {
35945                 Top, Bot                 []Box
35946                 Front, Left, Back, Right []Box
35947         }))(obj)).Back {
35948                 if err := pcall(func() {
35949                         (((*(*(struct {
35950                                 Top, Bot                 []Box
35951                                 Front, Left, Back, Right []Box
35952                         }))(obj)).Back)[local423]).deserialize(r)
35953                 }); err != nil {
35954                         if err == io.EOF {
35955                                 chk(io.EOF)
35956                         }
35957                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35958                 }
35959         }
35960         var local424 uint16
35961         {
35962                 p := &local424
35963                 *p = read16(r)
35964         }
35965         ((*(*(struct {
35966                 Top, Bot                 []Box
35967                 Front, Left, Back, Right []Box
35968         }))(obj)).Right) = make([]Box, local424)
35969         for local425 := range (*(*(struct {
35970                 Top, Bot                 []Box
35971                 Front, Left, Back, Right []Box
35972         }))(obj)).Right {
35973                 if err := pcall(func() {
35974                         (((*(*(struct {
35975                                 Top, Bot                 []Box
35976                                 Front, Left, Back, Right []Box
35977                         }))(obj)).Right)[local425]).deserialize(r)
35978                 }); err != nil {
35979                         if err == io.EOF {
35980                                 chk(io.EOF)
35981                         }
35982                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.Box", err))
35983                 }
35984         }
35985 }
35986
35987 func (obj *ToolGroupCap) serialize(w io.Writer) {
35988         if len(([]byte((*(*(struct {
35989                 Name string
35990
35991                 //mt:32to16
35992                 Uses int32
35993
35994                 MaxLvl int16
35995
35996                 //mt:len32
35997                 Times []DigTime
35998         }))(obj)).Name))) > math.MaxUint16 {
35999                 chk(ErrTooLong)
36000         }
36001         {
36002                 x := uint16(len(([]byte((*(*(struct {
36003                         Name string
36004
36005                         //mt:32to16
36006                         Uses int32
36007
36008                         MaxLvl int16
36009
36010                         //mt:len32
36011                         Times []DigTime
36012                 }))(obj)).Name))))
36013                 write16(w, uint16(x))
36014         }
36015         {
36016                 _, err := w.Write(([]byte((*(*(struct {
36017                         Name string
36018
36019                         //mt:32to16
36020                         Uses int32
36021
36022                         MaxLvl int16
36023
36024                         //mt:len32
36025                         Times []DigTime
36026                 }))(obj)).Name))[:])
36027                 chk(err)
36028         }
36029         {
36030                 x := int16((*(*(struct {
36031                         Name string
36032
36033                         //mt:32to16
36034                         Uses int32
36035
36036                         MaxLvl int16
36037
36038                         //mt:len32
36039                         Times []DigTime
36040                 }))(obj)).Uses)
36041                 write16(w, uint16(x))
36042         }
36043         {
36044                 x := (*(*(struct {
36045                         Name string
36046
36047                         //mt:32to16
36048                         Uses int32
36049
36050                         MaxLvl int16
36051
36052                         //mt:len32
36053                         Times []DigTime
36054                 }))(obj)).MaxLvl
36055                 write16(w, uint16(x))
36056         }
36057         if len(((*(*(struct {
36058                 Name string
36059
36060                 //mt:32to16
36061                 Uses int32
36062
36063                 MaxLvl int16
36064
36065                 //mt:len32
36066                 Times []DigTime
36067         }))(obj)).Times)) > math.MaxUint32 {
36068                 chk(ErrTooLong)
36069         }
36070         {
36071                 x := uint32(len(((*(*(struct {
36072                         Name string
36073
36074                         //mt:32to16
36075                         Uses int32
36076
36077                         MaxLvl int16
36078
36079                         //mt:len32
36080                         Times []DigTime
36081                 }))(obj)).Times)))
36082                 write32(w, uint32(x))
36083         }
36084         for local426 := range (*(*(struct {
36085                 Name string
36086
36087                 //mt:32to16
36088                 Uses int32
36089
36090                 MaxLvl int16
36091
36092                 //mt:len32
36093                 Times []DigTime
36094         }))(obj)).Times {
36095                 if err := pcall(func() {
36096                         (((*(*(struct {
36097                                 Name string
36098
36099                                 //mt:32to16
36100                                 Uses int32
36101
36102                                 MaxLvl int16
36103
36104                                 //mt:len32
36105                                 Times []DigTime
36106                         }))(obj)).Times)[local426]).serialize(w)
36107                 }); err != nil {
36108                         if err == io.EOF {
36109                                 chk(io.EOF)
36110                         }
36111                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
36112                 }
36113         }
36114 }
36115
36116 func (obj *ToolGroupCap) deserialize(r io.Reader) {
36117         var local427 []uint8
36118         var local428 uint16
36119         {
36120                 p := &local428
36121                 *p = read16(r)
36122         }
36123         (local427) = make([]uint8, local428)
36124         {
36125                 _, err := io.ReadFull(r, (local427)[:])
36126                 chk(err)
36127         }
36128         ((*(*(struct {
36129                 Name string
36130
36131                 //mt:32to16
36132                 Uses int32
36133
36134                 MaxLvl int16
36135
36136                 //mt:len32
36137                 Times []DigTime
36138         }))(obj)).Name) = string(local427)
36139         var local429 int16
36140         {
36141                 p := &local429
36142                 *p = int16(read16(r))
36143         }
36144         (*(*(struct {
36145                 Name string
36146
36147                 //mt:32to16
36148                 Uses int32
36149
36150                 MaxLvl int16
36151
36152                 //mt:len32
36153                 Times []DigTime
36154         }))(obj)).Uses = int32(local429)
36155         {
36156                 p := &(*(*(struct {
36157                         Name string
36158
36159                         //mt:32to16
36160                         Uses int32
36161
36162                         MaxLvl int16
36163
36164                         //mt:len32
36165                         Times []DigTime
36166                 }))(obj)).MaxLvl
36167                 *p = int16(read16(r))
36168         }
36169         var local430 uint32
36170         {
36171                 p := &local430
36172                 *p = read32(r)
36173         }
36174         ((*(*(struct {
36175                 Name string
36176
36177                 //mt:32to16
36178                 Uses int32
36179
36180                 MaxLvl int16
36181
36182                 //mt:len32
36183                 Times []DigTime
36184         }))(obj)).Times) = make([]DigTime, local430)
36185         for local431 := range (*(*(struct {
36186                 Name string
36187
36188                 //mt:32to16
36189                 Uses int32
36190
36191                 MaxLvl int16
36192
36193                 //mt:len32
36194                 Times []DigTime
36195         }))(obj)).Times {
36196                 if err := pcall(func() {
36197                         (((*(*(struct {
36198                                 Name string
36199
36200                                 //mt:32to16
36201                                 Uses int32
36202
36203                                 MaxLvl int16
36204
36205                                 //mt:len32
36206                                 Times []DigTime
36207                         }))(obj)).Times)[local431]).deserialize(r)
36208                 }); err != nil {
36209                         if err == io.EOF {
36210                                 chk(io.EOF)
36211                         }
36212                         chk(fmt.Errorf("%s: %w", "github.com/dragonfireclient/mt.DigTime", err))
36213                 }
36214         }
36215 }
36216
36217 func (obj *DigTime) serialize(w io.Writer) {
36218         {
36219                 x := (*(*(struct {
36220                         Rating int16
36221                         Time   float32
36222                 }))(obj)).Rating
36223                 write16(w, uint16(x))
36224         }
36225         {
36226                 x := (*(*(struct {
36227                         Rating int16
36228                         Time   float32
36229                 }))(obj)).Time
36230                 write32(w, math.Float32bits(x))
36231         }
36232 }
36233
36234 func (obj *DigTime) deserialize(r io.Reader) {
36235         {
36236                 p := &(*(*(struct {
36237                         Rating int16
36238                         Time   float32
36239                 }))(obj)).Rating
36240                 *p = int16(read16(r))
36241         }
36242         {
36243                 p := &(*(*(struct {
36244                         Rating int16
36245                         Time   float32
36246                 }))(obj)).Time
36247                 *p = math.Float32frombits(read32(r))
36248         }
36249 }