tests/monster_test_generated.js

   1 // automatically generated by the FlatBuffers compiler, do not modify
   2
   3 /**
   4  * @const
   5  * @namespace
   6  */
   7 var MyGame = MyGame || {};
   8
   9 /**
  10  * @const
  11  * @namespace
  12  */
  13 MyGame.Example = MyGame.Example || {};
  14
  15 /**
  16  * @const
  17  * @namespace
  18  */
  19 MyGame.Example2 = MyGame.Example2 || {};
  20
  21 /**
  22  * @const
  23  * @namespace
  24  */
  25 MyGame.OtherNameSpace = MyGame.OtherNameSpace || {};
  26
  27 /**
  28  * Composite components of Monster color.
  29  *
  30  * @enum {number}
  31  */
  32 MyGame.Example.Color = {
  33   Red: 1,
  34
  35   /**
  36    * \brief color Green
  37    * Green is bit_flag with value (1u << 1)
  38    */
  39   Green: 2,
  40
  41   /**
  42    * \brief color Blue (1u << 3)
  43    */
  44   Blue: 8
  45 };
  46
  47 /**
  48  * Composite components of Monster color.
  49  *
  50  * @enum {string}
  51  */
  52 MyGame.Example.ColorName = {
  53   '1': 'Red',
  54
  55   /**
  56    * \brief color Green
  57    * Green is bit_flag with value (1u << 1)
  58    */
  59   '2': 'Green',
  60
  61   /**
  62    * \brief color Blue (1u << 3)
  63    */
  64   '8': 'Blue'
  65 };
  66
  67 /**
  68  * @enum {number}
  69  */
  70 MyGame.Example.Race = {
  71   None: -1,
  72   Human: 0,
  73   Dwarf: 1,
  74   Elf: 2
  75 };
  76
  77 /**
  78  * @enum {string}
  79  */
  80 MyGame.Example.RaceName = {
  81   '-1': 'None',
  82   '0': 'Human',
  83   '1': 'Dwarf',
  84   '2': 'Elf'
  85 };
  86
  87 /**
  88  * @enum {number}
  89  */
  90 MyGame.Example.Any = {
  91   NONE: 0,
  92   Monster: 1,
  93   TestSimpleTableWithEnum: 2,
  94   MyGame_Example2_Monster: 3
  95 };
  96
  97 /**
  98  * @enum {string}
  99  */
 100 MyGame.Example.AnyName = {
 101   '0': 'NONE',
 102   '1': 'Monster',
 103   '2': 'TestSimpleTableWithEnum',
 104   '3': 'MyGame_Example2_Monster'
 105 };
 106
 107 /**
 108  * @enum {number}
 109  */
 110 MyGame.Example.AnyUniqueAliases = {
 111   NONE: 0,
 112   M: 1,
 113   TS: 2,
 114   M2: 3
 115 };
 116
 117 /**
 118  * @enum {string}
 119  */
 120 MyGame.Example.AnyUniqueAliasesName = {
 121   '0': 'NONE',
 122   '1': 'M',
 123   '2': 'TS',
 124   '3': 'M2'
 125 };
 126
 127 /**
 128  * @enum {number}
 129  */
 130 MyGame.Example.AnyAmbiguousAliases = {
 131   NONE: 0,
 132   M1: 1,
 133   M2: 2,
 134   M3: 3
 135 };
 136
 137 /**
 138  * @enum {string}
 139  */
 140 MyGame.Example.AnyAmbiguousAliasesName = {
 141   '0': 'NONE',
 142   '1': 'M1',
 143   '2': 'M2',
 144   '3': 'M3'
 145 };
 146
 147 /**
 148  * @constructor
 149  */
 150 MyGame.InParentNamespace = function() {
 151   /**
 152    * @type {flatbuffers.ByteBuffer}
 153    */
 154   this.bb = null;
 155
 156   /**
 157    * @type {number}
 158    */
 159   this.bb_pos = 0;
 160 };
 161
 162 /**
 163  * @param {number} i
 164  * @param {flatbuffers.ByteBuffer} bb
 165  * @returns {MyGame.InParentNamespace}
 166  */
 167 MyGame.InParentNamespace.prototype.__init = function(i, bb) {
 168   this.bb_pos = i;
 169   this.bb = bb;
 170   return this;
 171 };
 172
 173 /**
 174  * @param {flatbuffers.ByteBuffer} bb
 175  * @param {MyGame.InParentNamespace=} obj
 176  * @returns {MyGame.InParentNamespace}
 177  */
 178 MyGame.InParentNamespace.getRootAsInParentNamespace = function(bb, obj) {
 179   return (obj || new MyGame.InParentNamespace).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 180 };
 181
 182 /**
 183  * @param {flatbuffers.ByteBuffer} bb
 184  * @param {MyGame.InParentNamespace=} obj
 185  * @returns {MyGame.InParentNamespace}
 186  */
 187 MyGame.InParentNamespace.getSizePrefixedRootAsInParentNamespace = function(bb, obj) {
 188   return (obj || new MyGame.InParentNamespace).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 189 };
 190
 191 /**
 192  * @param {flatbuffers.Builder} builder
 193  */
 194 MyGame.InParentNamespace.startInParentNamespace = function(builder) {
 195   builder.startObject(0);
 196 };
 197
 198 /**
 199  * @param {flatbuffers.Builder} builder
 200  * @returns {flatbuffers.Offset}
 201  */
 202 MyGame.InParentNamespace.endInParentNamespace = function(builder) {
 203   var offset = builder.endObject();
 204   return offset;
 205 };
 206
 207 /**
 208  * @param {flatbuffers.Builder} builder
 209  * @returns {flatbuffers.Offset}
 210  */
 211 MyGame.InParentNamespace.createInParentNamespace = function(builder) {
 212   MyGame.InParentNamespace.startInParentNamespace(builder);
 213   return MyGame.InParentNamespace.endInParentNamespace(builder);
 214 }
 215
 216 /**
 217  * @constructor
 218  */
 219 MyGame.Example2.Monster = function() {
 220   /**
 221    * @type {flatbuffers.ByteBuffer}
 222    */
 223   this.bb = null;
 224
 225   /**
 226    * @type {number}
 227    */
 228   this.bb_pos = 0;
 229 };
 230
 231 /**
 232  * @param {number} i
 233  * @param {flatbuffers.ByteBuffer} bb
 234  * @returns {MyGame.Example2.Monster}
 235  */
 236 MyGame.Example2.Monster.prototype.__init = function(i, bb) {
 237   this.bb_pos = i;
 238   this.bb = bb;
 239   return this;
 240 };
 241
 242 /**
 243  * @param {flatbuffers.ByteBuffer} bb
 244  * @param {MyGame.Example2.Monster=} obj
 245  * @returns {MyGame.Example2.Monster}
 246  */
 247 MyGame.Example2.Monster.getRootAsMonster = function(bb, obj) {
 248   return (obj || new MyGame.Example2.Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 249 };
 250
 251 /**
 252  * @param {flatbuffers.ByteBuffer} bb
 253  * @param {MyGame.Example2.Monster=} obj
 254  * @returns {MyGame.Example2.Monster}
 255  */
 256 MyGame.Example2.Monster.getSizePrefixedRootAsMonster = function(bb, obj) {
 257   return (obj || new MyGame.Example2.Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 258 };
 259
 260 /**
 261  * @param {flatbuffers.Builder} builder
 262  */
 263 MyGame.Example2.Monster.startMonster = function(builder) {
 264   builder.startObject(0);
 265 };
 266
 267 /**
 268  * @param {flatbuffers.Builder} builder
 269  * @returns {flatbuffers.Offset}
 270  */
 271 MyGame.Example2.Monster.endMonster = function(builder) {
 272   var offset = builder.endObject();
 273   return offset;
 274 };
 275
 276 /**
 277  * @param {flatbuffers.Builder} builder
 278  * @returns {flatbuffers.Offset}
 279  */
 280 MyGame.Example2.Monster.createMonster = function(builder) {
 281   MyGame.Example2.Monster.startMonster(builder);
 282   return MyGame.Example2.Monster.endMonster(builder);
 283 }
 284
 285 /**
 286  * @constructor
 287  */
 288 MyGame.Example.Test = function() {
 289   /**
 290    * @type {flatbuffers.ByteBuffer}
 291    */
 292   this.bb = null;
 293
 294   /**
 295    * @type {number}
 296    */
 297   this.bb_pos = 0;
 298 };
 299
 300 /**
 301  * @param {number} i
 302  * @param {flatbuffers.ByteBuffer} bb
 303  * @returns {MyGame.Example.Test}
 304  */
 305 MyGame.Example.Test.prototype.__init = function(i, bb) {
 306   this.bb_pos = i;
 307   this.bb = bb;
 308   return this;
 309 };
 310
 311 /**
 312  * @returns {number}
 313  */
 314 MyGame.Example.Test.prototype.a = function() {
 315   return this.bb.readInt16(this.bb_pos);
 316 };
 317
 318 /**
 319  * @param {number} value
 320  * @returns {boolean}
 321  */
 322 MyGame.Example.Test.prototype.mutate_a = function(value) {
 323   var offset = this.bb.__offset(this.bb_pos, 0);
 324
 325   if (offset === 0) {
 326     return false;
 327   }
 328
 329   this.bb.writeInt16(this.bb_pos + offset, value);
 330   return true;
 331 };
 332
 333 /**
 334  * @returns {number}
 335  */
 336 MyGame.Example.Test.prototype.b = function() {
 337   return this.bb.readInt8(this.bb_pos + 2);
 338 };
 339
 340 /**
 341  * @param {number} value
 342  * @returns {boolean}
 343  */
 344 MyGame.Example.Test.prototype.mutate_b = function(value) {
 345   var offset = this.bb.__offset(this.bb_pos, 2);
 346
 347   if (offset === 0) {
 348     return false;
 349   }
 350
 351   this.bb.writeInt8(this.bb_pos + offset, value);
 352   return true;
 353 };
 354
 355 /**
 356  * @param {flatbuffers.Builder} builder
 357  * @param {number} a
 358  * @param {number} b
 359  * @returns {flatbuffers.Offset}
 360  */
 361 MyGame.Example.Test.createTest = function(builder, a, b) {
 362   builder.prep(2, 4);
 363   builder.pad(1);
 364   builder.writeInt8(b);
 365   builder.writeInt16(a);
 366   return builder.offset();
 367 };
 368
 369 /**
 370  * @constructor
 371  */
 372 MyGame.Example.TestSimpleTableWithEnum = function() {
 373   /**
 374    * @type {flatbuffers.ByteBuffer}
 375    */
 376   this.bb = null;
 377
 378   /**
 379    * @type {number}
 380    */
 381   this.bb_pos = 0;
 382 };
 383
 384 /**
 385  * @param {number} i
 386  * @param {flatbuffers.ByteBuffer} bb
 387  * @returns {MyGame.Example.TestSimpleTableWithEnum}
 388  */
 389 MyGame.Example.TestSimpleTableWithEnum.prototype.__init = function(i, bb) {
 390   this.bb_pos = i;
 391   this.bb = bb;
 392   return this;
 393 };
 394
 395 /**
 396  * @param {flatbuffers.ByteBuffer} bb
 397  * @param {MyGame.Example.TestSimpleTableWithEnum=} obj
 398  * @returns {MyGame.Example.TestSimpleTableWithEnum}
 399  */
 400 MyGame.Example.TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum = function(bb, obj) {
 401   return (obj || new MyGame.Example.TestSimpleTableWithEnum).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 402 };
 403
 404 /**
 405  * @param {flatbuffers.ByteBuffer} bb
 406  * @param {MyGame.Example.TestSimpleTableWithEnum=} obj
 407  * @returns {MyGame.Example.TestSimpleTableWithEnum}
 408  */
 409 MyGame.Example.TestSimpleTableWithEnum.getSizePrefixedRootAsTestSimpleTableWithEnum = function(bb, obj) {
 410   return (obj || new MyGame.Example.TestSimpleTableWithEnum).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 411 };
 412
 413 /**
 414  * @returns {MyGame.Example.Color}
 415  */
 416 MyGame.Example.TestSimpleTableWithEnum.prototype.color = function() {
 417   var offset = this.bb.__offset(this.bb_pos, 4);
 418   return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Color.Green;
 419 };
 420
 421 /**
 422  * @param {MyGame.Example.Color} value
 423  * @returns {boolean}
 424  */
 425 MyGame.Example.TestSimpleTableWithEnum.prototype.mutate_color = function(value) {
 426   var offset = this.bb.__offset(this.bb_pos, 4);
 427
 428   if (offset === 0) {
 429     return false;
 430   }
 431
 432   this.bb.writeUint8(this.bb_pos + offset, value);
 433   return true;
 434 };
 435
 436 /**
 437  * @param {flatbuffers.Builder} builder
 438  */
 439 MyGame.Example.TestSimpleTableWithEnum.startTestSimpleTableWithEnum = function(builder) {
 440   builder.startObject(1);
 441 };
 442
 443 /**
 444  * @param {flatbuffers.Builder} builder
 445  * @param {MyGame.Example.Color} color
 446  */
 447 MyGame.Example.TestSimpleTableWithEnum.addColor = function(builder, color) {
 448   builder.addFieldInt8(0, color, MyGame.Example.Color.Green);
 449 };
 450
 451 /**
 452  * @param {flatbuffers.Builder} builder
 453  * @returns {flatbuffers.Offset}
 454  */
 455 MyGame.Example.TestSimpleTableWithEnum.endTestSimpleTableWithEnum = function(builder) {
 456   var offset = builder.endObject();
 457   return offset;
 458 };
 459
 460 /**
 461  * @param {flatbuffers.Builder} builder
 462  * @param {MyGame.Example.Color} color
 463  * @returns {flatbuffers.Offset}
 464  */
 465 MyGame.Example.TestSimpleTableWithEnum.createTestSimpleTableWithEnum = function(builder, color) {
 466   MyGame.Example.TestSimpleTableWithEnum.startTestSimpleTableWithEnum(builder);
 467   MyGame.Example.TestSimpleTableWithEnum.addColor(builder, color);
 468   return MyGame.Example.TestSimpleTableWithEnum.endTestSimpleTableWithEnum(builder);
 469 }
 470
 471 /**
 472  * @constructor
 473  */
 474 MyGame.Example.Vec3 = function() {
 475   /**
 476    * @type {flatbuffers.ByteBuffer}
 477    */
 478   this.bb = null;
 479
 480   /**
 481    * @type {number}
 482    */
 483   this.bb_pos = 0;
 484 };
 485
 486 /**
 487  * @param {number} i
 488  * @param {flatbuffers.ByteBuffer} bb
 489  * @returns {MyGame.Example.Vec3}
 490  */
 491 MyGame.Example.Vec3.prototype.__init = function(i, bb) {
 492   this.bb_pos = i;
 493   this.bb = bb;
 494   return this;
 495 };
 496
 497 /**
 498  * @returns {number}
 499  */
 500 MyGame.Example.Vec3.prototype.x = function() {
 501   return this.bb.readFloat32(this.bb_pos);
 502 };
 503
 504 /**
 505  * @param {number} value
 506  * @returns {boolean}
 507  */
 508 MyGame.Example.Vec3.prototype.mutate_x = function(value) {
 509   var offset = this.bb.__offset(this.bb_pos, 0);
 510
 511   if (offset === 0) {
 512     return false;
 513   }
 514
 515   this.bb.writeFloat32(this.bb_pos + offset, value);
 516   return true;
 517 };
 518
 519 /**
 520  * @returns {number}
 521  */
 522 MyGame.Example.Vec3.prototype.y = function() {
 523   return this.bb.readFloat32(this.bb_pos + 4);
 524 };
 525
 526 /**
 527  * @param {number} value
 528  * @returns {boolean}
 529  */
 530 MyGame.Example.Vec3.prototype.mutate_y = function(value) {
 531   var offset = this.bb.__offset(this.bb_pos, 4);
 532
 533   if (offset === 0) {
 534     return false;
 535   }
 536
 537   this.bb.writeFloat32(this.bb_pos + offset, value);
 538   return true;
 539 };
 540
 541 /**
 542  * @returns {number}
 543  */
 544 MyGame.Example.Vec3.prototype.z = function() {
 545   return this.bb.readFloat32(this.bb_pos + 8);
 546 };
 547
 548 /**
 549  * @param {number} value
 550  * @returns {boolean}
 551  */
 552 MyGame.Example.Vec3.prototype.mutate_z = function(value) {
 553   var offset = this.bb.__offset(this.bb_pos, 8);
 554
 555   if (offset === 0) {
 556     return false;
 557   }
 558
 559   this.bb.writeFloat32(this.bb_pos + offset, value);
 560   return true;
 561 };
 562
 563 /**
 564  * @returns {number}
 565  */
 566 MyGame.Example.Vec3.prototype.test1 = function() {
 567   return this.bb.readFloat64(this.bb_pos + 16);
 568 };
 569
 570 /**
 571  * @param {number} value
 572  * @returns {boolean}
 573  */
 574 MyGame.Example.Vec3.prototype.mutate_test1 = function(value) {
 575   var offset = this.bb.__offset(this.bb_pos, 16);
 576
 577   if (offset === 0) {
 578     return false;
 579   }
 580
 581   this.bb.writeFloat64(this.bb_pos + offset, value);
 582   return true;
 583 };
 584
 585 /**
 586  * @returns {MyGame.Example.Color}
 587  */
 588 MyGame.Example.Vec3.prototype.test2 = function() {
 589   return /** @type {MyGame.Example.Color} */ (this.bb.readUint8(this.bb_pos + 24));
 590 };
 591
 592 /**
 593  * @param {MyGame.Example.Color} value
 594  * @returns {boolean}
 595  */
 596 MyGame.Example.Vec3.prototype.mutate_test2 = function(value) {
 597   var offset = this.bb.__offset(this.bb_pos, 24);
 598
 599   if (offset === 0) {
 600     return false;
 601   }
 602
 603   this.bb.writeUint8(this.bb_pos + offset, value);
 604   return true;
 605 };
 606
 607 /**
 608  * @param {MyGame.Example.Test=} obj
 609  * @returns {MyGame.Example.Test|null}
 610  */
 611 MyGame.Example.Vec3.prototype.test3 = function(obj) {
 612   return (obj || new MyGame.Example.Test).__init(this.bb_pos + 26, this.bb);
 613 };
 614
 615 /**
 616  * @param {flatbuffers.Builder} builder
 617  * @param {number} x
 618  * @param {number} y
 619  * @param {number} z
 620  * @param {number} test1
 621  * @param {MyGame.Example.Color} test2
 622  * @param {number} test3_a
 623  * @param {number} test3_b
 624  * @returns {flatbuffers.Offset}
 625  */
 626 MyGame.Example.Vec3.createVec3 = function(builder, x, y, z, test1, test2, test3_a, test3_b) {
 627   builder.prep(8, 32);
 628   builder.pad(2);
 629   builder.prep(2, 4);
 630   builder.pad(1);
 631   builder.writeInt8(test3_b);
 632   builder.writeInt16(test3_a);
 633   builder.pad(1);
 634   builder.writeInt8(test2);
 635   builder.writeFloat64(test1);
 636   builder.pad(4);
 637   builder.writeFloat32(z);
 638   builder.writeFloat32(y);
 639   builder.writeFloat32(x);
 640   return builder.offset();
 641 };
 642
 643 /**
 644  * @constructor
 645  */
 646 MyGame.Example.Ability = function() {
 647   /**
 648    * @type {flatbuffers.ByteBuffer}
 649    */
 650   this.bb = null;
 651
 652   /**
 653    * @type {number}
 654    */
 655   this.bb_pos = 0;
 656 };
 657
 658 /**
 659  * @param {number} i
 660  * @param {flatbuffers.ByteBuffer} bb
 661  * @returns {MyGame.Example.Ability}
 662  */
 663 MyGame.Example.Ability.prototype.__init = function(i, bb) {
 664   this.bb_pos = i;
 665   this.bb = bb;
 666   return this;
 667 };
 668
 669 /**
 670  * @returns {number}
 671  */
 672 MyGame.Example.Ability.prototype.id = function() {
 673   return this.bb.readUint32(this.bb_pos);
 674 };
 675
 676 /**
 677  * @param {number} value
 678  * @returns {boolean}
 679  */
 680 MyGame.Example.Ability.prototype.mutate_id = function(value) {
 681   var offset = this.bb.__offset(this.bb_pos, 0);
 682
 683   if (offset === 0) {
 684     return false;
 685   }
 686
 687   this.bb.writeUint32(this.bb_pos + offset, value);
 688   return true;
 689 };
 690
 691 /**
 692  * @returns {number}
 693  */
 694 MyGame.Example.Ability.prototype.distance = function() {
 695   return this.bb.readUint32(this.bb_pos + 4);
 696 };
 697
 698 /**
 699  * @param {number} value
 700  * @returns {boolean}
 701  */
 702 MyGame.Example.Ability.prototype.mutate_distance = function(value) {
 703   var offset = this.bb.__offset(this.bb_pos, 4);
 704
 705   if (offset === 0) {
 706     return false;
 707   }
 708
 709   this.bb.writeUint32(this.bb_pos + offset, value);
 710   return true;
 711 };
 712
 713 /**
 714  * @param {flatbuffers.Builder} builder
 715  * @param {number} id
 716  * @param {number} distance
 717  * @returns {flatbuffers.Offset}
 718  */
 719 MyGame.Example.Ability.createAbility = function(builder, id, distance) {
 720   builder.prep(4, 8);
 721   builder.writeInt32(distance);
 722   builder.writeInt32(id);
 723   return builder.offset();
 724 };
 725
 726 /**
 727  * @constructor
 728  */
 729 MyGame.Example.Stat = function() {
 730   /**
 731    * @type {flatbuffers.ByteBuffer}
 732    */
 733   this.bb = null;
 734
 735   /**
 736    * @type {number}
 737    */
 738   this.bb_pos = 0;
 739 };
 740
 741 /**
 742  * @param {number} i
 743  * @param {flatbuffers.ByteBuffer} bb
 744  * @returns {MyGame.Example.Stat}
 745  */
 746 MyGame.Example.Stat.prototype.__init = function(i, bb) {
 747   this.bb_pos = i;
 748   this.bb = bb;
 749   return this;
 750 };
 751
 752 /**
 753  * @param {flatbuffers.ByteBuffer} bb
 754  * @param {MyGame.Example.Stat=} obj
 755  * @returns {MyGame.Example.Stat}
 756  */
 757 MyGame.Example.Stat.getRootAsStat = function(bb, obj) {
 758   return (obj || new MyGame.Example.Stat).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 759 };
 760
 761 /**
 762  * @param {flatbuffers.ByteBuffer} bb
 763  * @param {MyGame.Example.Stat=} obj
 764  * @returns {MyGame.Example.Stat}
 765  */
 766 MyGame.Example.Stat.getSizePrefixedRootAsStat = function(bb, obj) {
 767   return (obj || new MyGame.Example.Stat).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 768 };
 769
 770 /**
 771  * @param {flatbuffers.Encoding=} optionalEncoding
 772  * @returns {string|Uint8Array|null}
 773  */
 774 MyGame.Example.Stat.prototype.id = function(optionalEncoding) {
 775   var offset = this.bb.__offset(this.bb_pos, 4);
 776   return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
 777 };
 778
 779 /**
 780  * @returns {flatbuffers.Long}
 781  */
 782 MyGame.Example.Stat.prototype.val = function() {
 783   var offset = this.bb.__offset(this.bb_pos, 6);
 784   return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
 785 };
 786
 787 /**
 788  * @param {flatbuffers.Long} value
 789  * @returns {boolean}
 790  */
 791 MyGame.Example.Stat.prototype.mutate_val = function(value) {
 792   var offset = this.bb.__offset(this.bb_pos, 6);
 793
 794   if (offset === 0) {
 795     return false;
 796   }
 797
 798   this.bb.writeInt64(this.bb_pos + offset, value);
 799   return true;
 800 };
 801
 802 /**
 803  * @returns {number}
 804  */
 805 MyGame.Example.Stat.prototype.count = function() {
 806   var offset = this.bb.__offset(this.bb_pos, 8);
 807   return offset ? this.bb.readUint16(this.bb_pos + offset) : 0;
 808 };
 809
 810 /**
 811  * @param {number} value
 812  * @returns {boolean}
 813  */
 814 MyGame.Example.Stat.prototype.mutate_count = function(value) {
 815   var offset = this.bb.__offset(this.bb_pos, 8);
 816
 817   if (offset === 0) {
 818     return false;
 819   }
 820
 821   this.bb.writeUint16(this.bb_pos + offset, value);
 822   return true;
 823 };
 824
 825 /**
 826  * @param {flatbuffers.Builder} builder
 827  */
 828 MyGame.Example.Stat.startStat = function(builder) {
 829   builder.startObject(3);
 830 };
 831
 832 /**
 833  * @param {flatbuffers.Builder} builder
 834  * @param {flatbuffers.Offset} idOffset
 835  */
 836 MyGame.Example.Stat.addId = function(builder, idOffset) {
 837   builder.addFieldOffset(0, idOffset, 0);
 838 };
 839
 840 /**
 841  * @param {flatbuffers.Builder} builder
 842  * @param {flatbuffers.Long} val
 843  */
 844 MyGame.Example.Stat.addVal = function(builder, val) {
 845   builder.addFieldInt64(1, val, builder.createLong(0, 0));
 846 };
 847
 848 /**
 849  * @param {flatbuffers.Builder} builder
 850  * @param {number} count
 851  */
 852 MyGame.Example.Stat.addCount = function(builder, count) {
 853   builder.addFieldInt16(2, count, 0);
 854 };
 855
 856 /**
 857  * @param {flatbuffers.Builder} builder
 858  * @returns {flatbuffers.Offset}
 859  */
 860 MyGame.Example.Stat.endStat = function(builder) {
 861   var offset = builder.endObject();
 862   return offset;
 863 };
 864
 865 /**
 866  * @param {flatbuffers.Builder} builder
 867  * @param {flatbuffers.Offset} idOffset
 868  * @param {flatbuffers.Long} val
 869  * @param {number} count
 870  * @returns {flatbuffers.Offset}
 871  */
 872 MyGame.Example.Stat.createStat = function(builder, idOffset, val, count) {
 873   MyGame.Example.Stat.startStat(builder);
 874   MyGame.Example.Stat.addId(builder, idOffset);
 875   MyGame.Example.Stat.addVal(builder, val);
 876   MyGame.Example.Stat.addCount(builder, count);
 877   return MyGame.Example.Stat.endStat(builder);
 878 }
 879
 880 /**
 881  * @constructor
 882  */
 883 MyGame.Example.Referrable = function() {
 884   /**
 885    * @type {flatbuffers.ByteBuffer}
 886    */
 887   this.bb = null;
 888
 889   /**
 890    * @type {number}
 891    */
 892   this.bb_pos = 0;
 893 };
 894
 895 /**
 896  * @param {number} i
 897  * @param {flatbuffers.ByteBuffer} bb
 898  * @returns {MyGame.Example.Referrable}
 899  */
 900 MyGame.Example.Referrable.prototype.__init = function(i, bb) {
 901   this.bb_pos = i;
 902   this.bb = bb;
 903   return this;
 904 };
 905
 906 /**
 907  * @param {flatbuffers.ByteBuffer} bb
 908  * @param {MyGame.Example.Referrable=} obj
 909  * @returns {MyGame.Example.Referrable}
 910  */
 911 MyGame.Example.Referrable.getRootAsReferrable = function(bb, obj) {
 912   return (obj || new MyGame.Example.Referrable).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 913 };
 914
 915 /**
 916  * @param {flatbuffers.ByteBuffer} bb
 917  * @param {MyGame.Example.Referrable=} obj
 918  * @returns {MyGame.Example.Referrable}
 919  */
 920 MyGame.Example.Referrable.getSizePrefixedRootAsReferrable = function(bb, obj) {
 921   return (obj || new MyGame.Example.Referrable).__init(bb.readInt32(bb.position()) + bb.position(), bb);
 922 };
 923
 924 /**
 925  * @returns {flatbuffers.Long}
 926  */
 927 MyGame.Example.Referrable.prototype.id = function() {
 928   var offset = this.bb.__offset(this.bb_pos, 4);
 929   return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0);
 930 };
 931
 932 /**
 933  * @param {flatbuffers.Long} value
 934  * @returns {boolean}
 935  */
 936 MyGame.Example.Referrable.prototype.mutate_id = function(value) {
 937   var offset = this.bb.__offset(this.bb_pos, 4);
 938
 939   if (offset === 0) {
 940     return false;
 941   }
 942
 943   this.bb.writeUint64(this.bb_pos + offset, value);
 944   return true;
 945 };
 946
 947 /**
 948  * @param {flatbuffers.Builder} builder
 949  */
 950 MyGame.Example.Referrable.startReferrable = function(builder) {
 951   builder.startObject(1);
 952 };
 953
 954 /**
 955  * @param {flatbuffers.Builder} builder
 956  * @param {flatbuffers.Long} id
 957  */
 958 MyGame.Example.Referrable.addId = function(builder, id) {
 959   builder.addFieldInt64(0, id, builder.createLong(0, 0));
 960 };
 961
 962 /**
 963  * @param {flatbuffers.Builder} builder
 964  * @returns {flatbuffers.Offset}
 965  */
 966 MyGame.Example.Referrable.endReferrable = function(builder) {
 967   var offset = builder.endObject();
 968   return offset;
 969 };
 970
 971 /**
 972  * @param {flatbuffers.Builder} builder
 973  * @param {flatbuffers.Long} id
 974  * @returns {flatbuffers.Offset}
 975  */
 976 MyGame.Example.Referrable.createReferrable = function(builder, id) {
 977   MyGame.Example.Referrable.startReferrable(builder);
 978   MyGame.Example.Referrable.addId(builder, id);
 979   return MyGame.Example.Referrable.endReferrable(builder);
 980 }
 981
 982 /**
 983  * an example documentation comment: monster object
 984  *
 985  * @constructor
 986  */
 987 MyGame.Example.Monster = function() {
 988   /**
 989    * @type {flatbuffers.ByteBuffer}
 990    */
 991   this.bb = null;
 992
 993   /**
 994    * @type {number}
 995    */
 996   this.bb_pos = 0;
 997 };
 998
 999 /**
1000  * @param {number} i
1001  * @param {flatbuffers.ByteBuffer} bb
1002  * @returns {MyGame.Example.Monster}
1003  */
1004 MyGame.Example.Monster.prototype.__init = function(i, bb) {
1005   this.bb_pos = i;
1006   this.bb = bb;
1007   return this;
1008 };
1009
1010 /**
1011  * @param {flatbuffers.ByteBuffer} bb
1012  * @param {MyGame.Example.Monster=} obj
1013  * @returns {MyGame.Example.Monster}
1014  */
1015 MyGame.Example.Monster.getRootAsMonster = function(bb, obj) {
1016   return (obj || new MyGame.Example.Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb);
1017 };
1018
1019 /**
1020  * @param {flatbuffers.ByteBuffer} bb
1021  * @param {MyGame.Example.Monster=} obj
1022  * @returns {MyGame.Example.Monster}
1023  */
1024 MyGame.Example.Monster.getSizePrefixedRootAsMonster = function(bb, obj) {
1025   return (obj || new MyGame.Example.Monster).__init(bb.readInt32(bb.position()) + bb.position(), bb);
1026 };
1027
1028 /**
1029  * @param {flatbuffers.ByteBuffer} bb
1030  * @returns {boolean}
1031  */
1032 MyGame.Example.Monster.bufferHasIdentifier = function(bb) {
1033   return bb.__has_identifier('MONS');
1034 };
1035
1036 /**
1037  * @param {MyGame.Example.Vec3=} obj
1038  * @returns {MyGame.Example.Vec3|null}
1039  */
1040 MyGame.Example.Monster.prototype.pos = function(obj) {
1041   var offset = this.bb.__offset(this.bb_pos, 4);
1042   return offset ? (obj || new MyGame.Example.Vec3).__init(this.bb_pos + offset, this.bb) : null;
1043 };
1044
1045 /**
1046  * @returns {number}
1047  */
1048 MyGame.Example.Monster.prototype.mana = function() {
1049   var offset = this.bb.__offset(this.bb_pos, 6);
1050   return offset ? this.bb.readInt16(this.bb_pos + offset) : 150;
1051 };
1052
1053 /**
1054  * @param {number} value
1055  * @returns {boolean}
1056  */
1057 MyGame.Example.Monster.prototype.mutate_mana = function(value) {
1058   var offset = this.bb.__offset(this.bb_pos, 6);
1059
1060   if (offset === 0) {
1061     return false;
1062   }
1063
1064   this.bb.writeInt16(this.bb_pos + offset, value);
1065   return true;
1066 };
1067
1068 /**
1069  * @returns {number}
1070  */
1071 MyGame.Example.Monster.prototype.hp = function() {
1072   var offset = this.bb.__offset(this.bb_pos, 8);
1073   return offset ? this.bb.readInt16(this.bb_pos + offset) : 100;
1074 };
1075
1076 /**
1077  * @param {number} value
1078  * @returns {boolean}
1079  */
1080 MyGame.Example.Monster.prototype.mutate_hp = function(value) {
1081   var offset = this.bb.__offset(this.bb_pos, 8);
1082
1083   if (offset === 0) {
1084     return false;
1085   }
1086
1087   this.bb.writeInt16(this.bb_pos + offset, value);
1088   return true;
1089 };
1090
1091 /**
1092  * @param {flatbuffers.Encoding=} optionalEncoding
1093  * @returns {string|Uint8Array|null}
1094  */
1095 MyGame.Example.Monster.prototype.name = function(optionalEncoding) {
1096   var offset = this.bb.__offset(this.bb_pos, 10);
1097   return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
1098 };
1099
1100 /**
1101  * @param {number} index
1102  * @returns {number}
1103  */
1104 MyGame.Example.Monster.prototype.inventory = function(index) {
1105   var offset = this.bb.__offset(this.bb_pos, 14);
1106   return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
1107 };
1108
1109 /**
1110  * @returns {number}
1111  */
1112 MyGame.Example.Monster.prototype.inventoryLength = function() {
1113   var offset = this.bb.__offset(this.bb_pos, 14);
1114   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1115 };
1116
1117 /**
1118  * @returns {Uint8Array}
1119  */
1120 MyGame.Example.Monster.prototype.inventoryArray = function() {
1121   var offset = this.bb.__offset(this.bb_pos, 14);
1122   return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
1123 };
1124
1125 /**
1126  * @returns {MyGame.Example.Color}
1127  */
1128 MyGame.Example.Monster.prototype.color = function() {
1129   var offset = this.bb.__offset(this.bb_pos, 16);
1130   return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Color.Blue;
1131 };
1132
1133 /**
1134  * @param {MyGame.Example.Color} value
1135  * @returns {boolean}
1136  */
1137 MyGame.Example.Monster.prototype.mutate_color = function(value) {
1138   var offset = this.bb.__offset(this.bb_pos, 16);
1139
1140   if (offset === 0) {
1141     return false;
1142   }
1143
1144   this.bb.writeUint8(this.bb_pos + offset, value);
1145   return true;
1146 };
1147
1148 /**
1149  * @returns {MyGame.Example.Any}
1150  */
1151 MyGame.Example.Monster.prototype.testType = function() {
1152   var offset = this.bb.__offset(this.bb_pos, 18);
1153   return offset ? /** @type {MyGame.Example.Any} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.Any.NONE;
1154 };
1155
1156 /**
1157  * @param {flatbuffers.Table} obj
1158  * @returns {?flatbuffers.Table}
1159  */
1160 MyGame.Example.Monster.prototype.test = function(obj) {
1161   var offset = this.bb.__offset(this.bb_pos, 20);
1162   return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
1163 };
1164
1165 /**
1166  * @param {number} index
1167  * @param {MyGame.Example.Test=} obj
1168  * @returns {MyGame.Example.Test}
1169  */
1170 MyGame.Example.Monster.prototype.test4 = function(index, obj) {
1171   var offset = this.bb.__offset(this.bb_pos, 22);
1172   return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null;
1173 };
1174
1175 /**
1176  * @returns {number}
1177  */
1178 MyGame.Example.Monster.prototype.test4Length = function() {
1179   var offset = this.bb.__offset(this.bb_pos, 22);
1180   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1181 };
1182
1183 /**
1184  * @param {number} index
1185  * @param {flatbuffers.Encoding=} optionalEncoding
1186  * @returns {string|Uint8Array}
1187  */
1188 MyGame.Example.Monster.prototype.testarrayofstring = function(index, optionalEncoding) {
1189   var offset = this.bb.__offset(this.bb_pos, 24);
1190   return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
1191 };
1192
1193 /**
1194  * @returns {number}
1195  */
1196 MyGame.Example.Monster.prototype.testarrayofstringLength = function() {
1197   var offset = this.bb.__offset(this.bb_pos, 24);
1198   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1199 };
1200
1201 /**
1202  * an example documentation comment: this will end up in the generated code
1203  * multiline too
1204  *
1205  * @param {number} index
1206  * @param {MyGame.Example.Monster=} obj
1207  * @returns {MyGame.Example.Monster}
1208  */
1209 MyGame.Example.Monster.prototype.testarrayoftables = function(index, obj) {
1210   var offset = this.bb.__offset(this.bb_pos, 26);
1211   return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
1212 };
1213
1214 /**
1215  * @returns {number}
1216  */
1217 MyGame.Example.Monster.prototype.testarrayoftablesLength = function() {
1218   var offset = this.bb.__offset(this.bb_pos, 26);
1219   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1220 };
1221
1222 /**
1223  * @param {MyGame.Example.Monster=} obj
1224  * @returns {MyGame.Example.Monster|null}
1225  */
1226 MyGame.Example.Monster.prototype.enemy = function(obj) {
1227   var offset = this.bb.__offset(this.bb_pos, 28);
1228   return offset ? (obj || new MyGame.Example.Monster).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
1229 };
1230
1231 /**
1232  * @param {number} index
1233  * @returns {number}
1234  */
1235 MyGame.Example.Monster.prototype.testnestedflatbuffer = function(index) {
1236   var offset = this.bb.__offset(this.bb_pos, 30);
1237   return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
1238 };
1239
1240 /**
1241  * @returns {number}
1242  */
1243 MyGame.Example.Monster.prototype.testnestedflatbufferLength = function() {
1244   var offset = this.bb.__offset(this.bb_pos, 30);
1245   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1246 };
1247
1248 /**
1249  * @returns {Uint8Array}
1250  */
1251 MyGame.Example.Monster.prototype.testnestedflatbufferArray = function() {
1252   var offset = this.bb.__offset(this.bb_pos, 30);
1253   return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
1254 };
1255
1256 /**
1257  * @param {MyGame.Example.Stat=} obj
1258  * @returns {MyGame.Example.Stat|null}
1259  */
1260 MyGame.Example.Monster.prototype.testempty = function(obj) {
1261   var offset = this.bb.__offset(this.bb_pos, 32);
1262   return offset ? (obj || new MyGame.Example.Stat).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
1263 };
1264
1265 /**
1266  * @returns {boolean}
1267  */
1268 MyGame.Example.Monster.prototype.testbool = function() {
1269   var offset = this.bb.__offset(this.bb_pos, 34);
1270   return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
1271 };
1272
1273 /**
1274  * @param {boolean} value
1275  * @returns {boolean}
1276  */
1277 MyGame.Example.Monster.prototype.mutate_testbool = function(value) {
1278   var offset = this.bb.__offset(this.bb_pos, 34);
1279
1280   if (offset === 0) {
1281     return false;
1282   }
1283
1284   this.bb.writeInt8(this.bb_pos + offset, value);
1285   return true;
1286 };
1287
1288 /**
1289  * @returns {number}
1290  */
1291 MyGame.Example.Monster.prototype.testhashs32Fnv1 = function() {
1292   var offset = this.bb.__offset(this.bb_pos, 36);
1293   return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
1294 };
1295
1296 /**
1297  * @param {number} value
1298  * @returns {boolean}
1299  */
1300 MyGame.Example.Monster.prototype.mutate_testhashs32_fnv1 = function(value) {
1301   var offset = this.bb.__offset(this.bb_pos, 36);
1302
1303   if (offset === 0) {
1304     return false;
1305   }
1306
1307   this.bb.writeInt32(this.bb_pos + offset, value);
1308   return true;
1309 };
1310
1311 /**
1312  * @returns {number}
1313  */
1314 MyGame.Example.Monster.prototype.testhashu32Fnv1 = function() {
1315   var offset = this.bb.__offset(this.bb_pos, 38);
1316   return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
1317 };
1318
1319 /**
1320  * @param {number} value
1321  * @returns {boolean}
1322  */
1323 MyGame.Example.Monster.prototype.mutate_testhashu32_fnv1 = function(value) {
1324   var offset = this.bb.__offset(this.bb_pos, 38);
1325
1326   if (offset === 0) {
1327     return false;
1328   }
1329
1330   this.bb.writeUint32(this.bb_pos + offset, value);
1331   return true;
1332 };
1333
1334 /**
1335  * @returns {flatbuffers.Long}
1336  */
1337 MyGame.Example.Monster.prototype.testhashs64Fnv1 = function() {
1338   var offset = this.bb.__offset(this.bb_pos, 40);
1339   return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
1340 };
1341
1342 /**
1343  * @param {flatbuffers.Long} value
1344  * @returns {boolean}
1345  */
1346 MyGame.Example.Monster.prototype.mutate_testhashs64_fnv1 = function(value) {
1347   var offset = this.bb.__offset(this.bb_pos, 40);
1348
1349   if (offset === 0) {
1350     return false;
1351   }
1352
1353   this.bb.writeInt64(this.bb_pos + offset, value);
1354   return true;
1355 };
1356
1357 /**
1358  * @returns {flatbuffers.Long}
1359  */
1360 MyGame.Example.Monster.prototype.testhashu64Fnv1 = function() {
1361   var offset = this.bb.__offset(this.bb_pos, 42);
1362   return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0);
1363 };
1364
1365 /**
1366  * @param {flatbuffers.Long} value
1367  * @returns {boolean}
1368  */
1369 MyGame.Example.Monster.prototype.mutate_testhashu64_fnv1 = function(value) {
1370   var offset = this.bb.__offset(this.bb_pos, 42);
1371
1372   if (offset === 0) {
1373     return false;
1374   }
1375
1376   this.bb.writeUint64(this.bb_pos + offset, value);
1377   return true;
1378 };
1379
1380 /**
1381  * @returns {number}
1382  */
1383 MyGame.Example.Monster.prototype.testhashs32Fnv1a = function() {
1384   var offset = this.bb.__offset(this.bb_pos, 44);
1385   return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
1386 };
1387
1388 /**
1389  * @param {number} value
1390  * @returns {boolean}
1391  */
1392 MyGame.Example.Monster.prototype.mutate_testhashs32_fnv1a = function(value) {
1393   var offset = this.bb.__offset(this.bb_pos, 44);
1394
1395   if (offset === 0) {
1396     return false;
1397   }
1398
1399   this.bb.writeInt32(this.bb_pos + offset, value);
1400   return true;
1401 };
1402
1403 /**
1404  * @returns {number}
1405  */
1406 MyGame.Example.Monster.prototype.testhashu32Fnv1a = function() {
1407   var offset = this.bb.__offset(this.bb_pos, 46);
1408   return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
1409 };
1410
1411 /**
1412  * @param {number} value
1413  * @returns {boolean}
1414  */
1415 MyGame.Example.Monster.prototype.mutate_testhashu32_fnv1a = function(value) {
1416   var offset = this.bb.__offset(this.bb_pos, 46);
1417
1418   if (offset === 0) {
1419     return false;
1420   }
1421
1422   this.bb.writeUint32(this.bb_pos + offset, value);
1423   return true;
1424 };
1425
1426 /**
1427  * @returns {flatbuffers.Long}
1428  */
1429 MyGame.Example.Monster.prototype.testhashs64Fnv1a = function() {
1430   var offset = this.bb.__offset(this.bb_pos, 48);
1431   return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
1432 };
1433
1434 /**
1435  * @param {flatbuffers.Long} value
1436  * @returns {boolean}
1437  */
1438 MyGame.Example.Monster.prototype.mutate_testhashs64_fnv1a = function(value) {
1439   var offset = this.bb.__offset(this.bb_pos, 48);
1440
1441   if (offset === 0) {
1442     return false;
1443   }
1444
1445   this.bb.writeInt64(this.bb_pos + offset, value);
1446   return true;
1447 };
1448
1449 /**
1450  * @returns {flatbuffers.Long}
1451  */
1452 MyGame.Example.Monster.prototype.testhashu64Fnv1a = function() {
1453   var offset = this.bb.__offset(this.bb_pos, 50);
1454   return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0);
1455 };
1456
1457 /**
1458  * @param {flatbuffers.Long} value
1459  * @returns {boolean}
1460  */
1461 MyGame.Example.Monster.prototype.mutate_testhashu64_fnv1a = function(value) {
1462   var offset = this.bb.__offset(this.bb_pos, 50);
1463
1464   if (offset === 0) {
1465     return false;
1466   }
1467
1468   this.bb.writeUint64(this.bb_pos + offset, value);
1469   return true;
1470 };
1471
1472 /**
1473  * @param {number} index
1474  * @returns {boolean}
1475  */
1476 MyGame.Example.Monster.prototype.testarrayofbools = function(index) {
1477   var offset = this.bb.__offset(this.bb_pos, 52);
1478   return offset ? !!this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : false;
1479 };
1480
1481 /**
1482  * @returns {number}
1483  */
1484 MyGame.Example.Monster.prototype.testarrayofboolsLength = function() {
1485   var offset = this.bb.__offset(this.bb_pos, 52);
1486   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1487 };
1488
1489 /**
1490  * @returns {Int8Array}
1491  */
1492 MyGame.Example.Monster.prototype.testarrayofboolsArray = function() {
1493   var offset = this.bb.__offset(this.bb_pos, 52);
1494   return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
1495 };
1496
1497 /**
1498  * @returns {number}
1499  */
1500 MyGame.Example.Monster.prototype.testf = function() {
1501   var offset = this.bb.__offset(this.bb_pos, 54);
1502   return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.14159;
1503 };
1504
1505 /**
1506  * @param {number} value
1507  * @returns {boolean}
1508  */
1509 MyGame.Example.Monster.prototype.mutate_testf = function(value) {
1510   var offset = this.bb.__offset(this.bb_pos, 54);
1511
1512   if (offset === 0) {
1513     return false;
1514   }
1515
1516   this.bb.writeFloat32(this.bb_pos + offset, value);
1517   return true;
1518 };
1519
1520 /**
1521  * @returns {number}
1522  */
1523 MyGame.Example.Monster.prototype.testf2 = function() {
1524   var offset = this.bb.__offset(this.bb_pos, 56);
1525   return offset ? this.bb.readFloat32(this.bb_pos + offset) : 3.0;
1526 };
1527
1528 /**
1529  * @param {number} value
1530  * @returns {boolean}
1531  */
1532 MyGame.Example.Monster.prototype.mutate_testf2 = function(value) {
1533   var offset = this.bb.__offset(this.bb_pos, 56);
1534
1535   if (offset === 0) {
1536     return false;
1537   }
1538
1539   this.bb.writeFloat32(this.bb_pos + offset, value);
1540   return true;
1541 };
1542
1543 /**
1544  * @returns {number}
1545  */
1546 MyGame.Example.Monster.prototype.testf3 = function() {
1547   var offset = this.bb.__offset(this.bb_pos, 58);
1548   return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
1549 };
1550
1551 /**
1552  * @param {number} value
1553  * @returns {boolean}
1554  */
1555 MyGame.Example.Monster.prototype.mutate_testf3 = function(value) {
1556   var offset = this.bb.__offset(this.bb_pos, 58);
1557
1558   if (offset === 0) {
1559     return false;
1560   }
1561
1562   this.bb.writeFloat32(this.bb_pos + offset, value);
1563   return true;
1564 };
1565
1566 /**
1567  * @param {number} index
1568  * @param {flatbuffers.Encoding=} optionalEncoding
1569  * @returns {string|Uint8Array}
1570  */
1571 MyGame.Example.Monster.prototype.testarrayofstring2 = function(index, optionalEncoding) {
1572   var offset = this.bb.__offset(this.bb_pos, 60);
1573   return offset ? this.bb.__string(this.bb.__vector(this.bb_pos + offset) + index * 4, optionalEncoding) : null;
1574 };
1575
1576 /**
1577  * @returns {number}
1578  */
1579 MyGame.Example.Monster.prototype.testarrayofstring2Length = function() {
1580   var offset = this.bb.__offset(this.bb_pos, 60);
1581   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1582 };
1583
1584 /**
1585  * @param {number} index
1586  * @param {MyGame.Example.Ability=} obj
1587  * @returns {MyGame.Example.Ability}
1588  */
1589 MyGame.Example.Monster.prototype.testarrayofsortedstruct = function(index, obj) {
1590   var offset = this.bb.__offset(this.bb_pos, 62);
1591   return offset ? (obj || new MyGame.Example.Ability).__init(this.bb.__vector(this.bb_pos + offset) + index * 8, this.bb) : null;
1592 };
1593
1594 /**
1595  * @returns {number}
1596  */
1597 MyGame.Example.Monster.prototype.testarrayofsortedstructLength = function() {
1598   var offset = this.bb.__offset(this.bb_pos, 62);
1599   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1600 };
1601
1602 /**
1603  * @param {number} index
1604  * @returns {number}
1605  */
1606 MyGame.Example.Monster.prototype.flex = function(index) {
1607   var offset = this.bb.__offset(this.bb_pos, 64);
1608   return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
1609 };
1610
1611 /**
1612  * @returns {number}
1613  */
1614 MyGame.Example.Monster.prototype.flexLength = function() {
1615   var offset = this.bb.__offset(this.bb_pos, 64);
1616   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1617 };
1618
1619 /**
1620  * @returns {Uint8Array}
1621  */
1622 MyGame.Example.Monster.prototype.flexArray = function() {
1623   var offset = this.bb.__offset(this.bb_pos, 64);
1624   return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
1625 };
1626
1627 /**
1628  * @param {number} index
1629  * @param {MyGame.Example.Test=} obj
1630  * @returns {MyGame.Example.Test}
1631  */
1632 MyGame.Example.Monster.prototype.test5 = function(index, obj) {
1633   var offset = this.bb.__offset(this.bb_pos, 66);
1634   return offset ? (obj || new MyGame.Example.Test).__init(this.bb.__vector(this.bb_pos + offset) + index * 4, this.bb) : null;
1635 };
1636
1637 /**
1638  * @returns {number}
1639  */
1640 MyGame.Example.Monster.prototype.test5Length = function() {
1641   var offset = this.bb.__offset(this.bb_pos, 66);
1642   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1643 };
1644
1645 /**
1646  * @param {number} index
1647  * @returns {flatbuffers.Long}
1648  */
1649 MyGame.Example.Monster.prototype.vectorOfLongs = function(index) {
1650   var offset = this.bb.__offset(this.bb_pos, 68);
1651   return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
1652 };
1653
1654 /**
1655  * @returns {number}
1656  */
1657 MyGame.Example.Monster.prototype.vectorOfLongsLength = function() {
1658   var offset = this.bb.__offset(this.bb_pos, 68);
1659   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1660 };
1661
1662 /**
1663  * @param {number} index
1664  * @returns {number}
1665  */
1666 MyGame.Example.Monster.prototype.vectorOfDoubles = function(index) {
1667   var offset = this.bb.__offset(this.bb_pos, 70);
1668   return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
1669 };
1670
1671 /**
1672  * @returns {number}
1673  */
1674 MyGame.Example.Monster.prototype.vectorOfDoublesLength = function() {
1675   var offset = this.bb.__offset(this.bb_pos, 70);
1676   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1677 };
1678
1679 /**
1680  * @returns {Float64Array}
1681  */
1682 MyGame.Example.Monster.prototype.vectorOfDoublesArray = function() {
1683   var offset = this.bb.__offset(this.bb_pos, 70);
1684   return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
1685 };
1686
1687 /**
1688  * @param {MyGame.InParentNamespace=} obj
1689  * @returns {MyGame.InParentNamespace|null}
1690  */
1691 MyGame.Example.Monster.prototype.parentNamespaceTest = function(obj) {
1692   var offset = this.bb.__offset(this.bb_pos, 72);
1693   return offset ? (obj || new MyGame.InParentNamespace).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
1694 };
1695
1696 /**
1697  * @param {number} index
1698  * @param {MyGame.Example.Referrable=} obj
1699  * @returns {MyGame.Example.Referrable}
1700  */
1701 MyGame.Example.Monster.prototype.vectorOfReferrables = function(index, obj) {
1702   var offset = this.bb.__offset(this.bb_pos, 74);
1703   return offset ? (obj || new MyGame.Example.Referrable).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
1704 };
1705
1706 /**
1707  * @returns {number}
1708  */
1709 MyGame.Example.Monster.prototype.vectorOfReferrablesLength = function() {
1710   var offset = this.bb.__offset(this.bb_pos, 74);
1711   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1712 };
1713
1714 /**
1715  * @returns {flatbuffers.Long}
1716  */
1717 MyGame.Example.Monster.prototype.singleWeakReference = function() {
1718   var offset = this.bb.__offset(this.bb_pos, 76);
1719   return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0);
1720 };
1721
1722 /**
1723  * @param {flatbuffers.Long} value
1724  * @returns {boolean}
1725  */
1726 MyGame.Example.Monster.prototype.mutate_single_weak_reference = function(value) {
1727   var offset = this.bb.__offset(this.bb_pos, 76);
1728
1729   if (offset === 0) {
1730     return false;
1731   }
1732
1733   this.bb.writeUint64(this.bb_pos + offset, value);
1734   return true;
1735 };
1736
1737 /**
1738  * @param {number} index
1739  * @returns {flatbuffers.Long}
1740  */
1741 MyGame.Example.Monster.prototype.vectorOfWeakReferences = function(index) {
1742   var offset = this.bb.__offset(this.bb_pos, 78);
1743   return offset ? this.bb.readUint64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
1744 };
1745
1746 /**
1747  * @returns {number}
1748  */
1749 MyGame.Example.Monster.prototype.vectorOfWeakReferencesLength = function() {
1750   var offset = this.bb.__offset(this.bb_pos, 78);
1751   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1752 };
1753
1754 /**
1755  * @param {number} index
1756  * @param {MyGame.Example.Referrable=} obj
1757  * @returns {MyGame.Example.Referrable}
1758  */
1759 MyGame.Example.Monster.prototype.vectorOfStrongReferrables = function(index, obj) {
1760   var offset = this.bb.__offset(this.bb_pos, 80);
1761   return offset ? (obj || new MyGame.Example.Referrable).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
1762 };
1763
1764 /**
1765  * @returns {number}
1766  */
1767 MyGame.Example.Monster.prototype.vectorOfStrongReferrablesLength = function() {
1768   var offset = this.bb.__offset(this.bb_pos, 80);
1769   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1770 };
1771
1772 /**
1773  * @returns {flatbuffers.Long}
1774  */
1775 MyGame.Example.Monster.prototype.coOwningReference = function() {
1776   var offset = this.bb.__offset(this.bb_pos, 82);
1777   return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0);
1778 };
1779
1780 /**
1781  * @param {flatbuffers.Long} value
1782  * @returns {boolean}
1783  */
1784 MyGame.Example.Monster.prototype.mutate_co_owning_reference = function(value) {
1785   var offset = this.bb.__offset(this.bb_pos, 82);
1786
1787   if (offset === 0) {
1788     return false;
1789   }
1790
1791   this.bb.writeUint64(this.bb_pos + offset, value);
1792   return true;
1793 };
1794
1795 /**
1796  * @param {number} index
1797  * @returns {flatbuffers.Long}
1798  */
1799 MyGame.Example.Monster.prototype.vectorOfCoOwningReferences = function(index) {
1800   var offset = this.bb.__offset(this.bb_pos, 84);
1801   return offset ? this.bb.readUint64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
1802 };
1803
1804 /**
1805  * @returns {number}
1806  */
1807 MyGame.Example.Monster.prototype.vectorOfCoOwningReferencesLength = function() {
1808   var offset = this.bb.__offset(this.bb_pos, 84);
1809   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1810 };
1811
1812 /**
1813  * @returns {flatbuffers.Long}
1814  */
1815 MyGame.Example.Monster.prototype.nonOwningReference = function() {
1816   var offset = this.bb.__offset(this.bb_pos, 86);
1817   return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0);
1818 };
1819
1820 /**
1821  * @param {flatbuffers.Long} value
1822  * @returns {boolean}
1823  */
1824 MyGame.Example.Monster.prototype.mutate_non_owning_reference = function(value) {
1825   var offset = this.bb.__offset(this.bb_pos, 86);
1826
1827   if (offset === 0) {
1828     return false;
1829   }
1830
1831   this.bb.writeUint64(this.bb_pos + offset, value);
1832   return true;
1833 };
1834
1835 /**
1836  * @param {number} index
1837  * @returns {flatbuffers.Long}
1838  */
1839 MyGame.Example.Monster.prototype.vectorOfNonOwningReferences = function(index) {
1840   var offset = this.bb.__offset(this.bb_pos, 88);
1841   return offset ? this.bb.readUint64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0);
1842 };
1843
1844 /**
1845  * @returns {number}
1846  */
1847 MyGame.Example.Monster.prototype.vectorOfNonOwningReferencesLength = function() {
1848   var offset = this.bb.__offset(this.bb_pos, 88);
1849   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1850 };
1851
1852 /**
1853  * @returns {MyGame.Example.AnyUniqueAliases}
1854  */
1855 MyGame.Example.Monster.prototype.anyUniqueType = function() {
1856   var offset = this.bb.__offset(this.bb_pos, 90);
1857   return offset ? /** @type {MyGame.Example.AnyUniqueAliases} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.AnyUniqueAliases.NONE;
1858 };
1859
1860 /**
1861  * @param {flatbuffers.Table} obj
1862  * @returns {?flatbuffers.Table}
1863  */
1864 MyGame.Example.Monster.prototype.anyUnique = function(obj) {
1865   var offset = this.bb.__offset(this.bb_pos, 92);
1866   return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
1867 };
1868
1869 /**
1870  * @returns {MyGame.Example.AnyAmbiguousAliases}
1871  */
1872 MyGame.Example.Monster.prototype.anyAmbiguousType = function() {
1873   var offset = this.bb.__offset(this.bb_pos, 94);
1874   return offset ? /** @type {MyGame.Example.AnyAmbiguousAliases} */ (this.bb.readUint8(this.bb_pos + offset)) : MyGame.Example.AnyAmbiguousAliases.NONE;
1875 };
1876
1877 /**
1878  * @param {flatbuffers.Table} obj
1879  * @returns {?flatbuffers.Table}
1880  */
1881 MyGame.Example.Monster.prototype.anyAmbiguous = function(obj) {
1882   var offset = this.bb.__offset(this.bb_pos, 96);
1883   return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
1884 };
1885
1886 /**
1887  * @param {number} index
1888  * @returns {MyGame.Example.Color}
1889  */
1890 MyGame.Example.Monster.prototype.vectorOfEnums = function(index) {
1891   var offset = this.bb.__offset(this.bb_pos, 98);
1892   return offset ? /** @type {MyGame.Example.Color} */ (this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index)) : /** @type {MyGame.Example.Color} */ (0);
1893 };
1894
1895 /**
1896  * @returns {number}
1897  */
1898 MyGame.Example.Monster.prototype.vectorOfEnumsLength = function() {
1899   var offset = this.bb.__offset(this.bb_pos, 98);
1900   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
1901 };
1902
1903 /**
1904  * @returns {Uint8Array}
1905  */
1906 MyGame.Example.Monster.prototype.vectorOfEnumsArray = function() {
1907   var offset = this.bb.__offset(this.bb_pos, 98);
1908   return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
1909 };
1910
1911 /**
1912  * @returns {MyGame.Example.Race}
1913  */
1914 MyGame.Example.Monster.prototype.signedEnum = function() {
1915   var offset = this.bb.__offset(this.bb_pos, 100);
1916   return offset ? /** @type {MyGame.Example.Race} */ (this.bb.readInt8(this.bb_pos + offset)) : MyGame.Example.Race.None;
1917 };
1918
1919 /**
1920  * @param {MyGame.Example.Race} value
1921  * @returns {boolean}
1922  */
1923 MyGame.Example.Monster.prototype.mutate_signed_enum = function(value) {
1924   var offset = this.bb.__offset(this.bb_pos, 100);
1925
1926   if (offset === 0) {
1927     return false;
1928   }
1929
1930   this.bb.writeInt8(this.bb_pos + offset, value);
1931   return true;
1932 };
1933
1934 /**
1935  * @param {flatbuffers.Builder} builder
1936  */
1937 MyGame.Example.Monster.startMonster = function(builder) {
1938   builder.startObject(49);
1939 };
1940
1941 /**
1942  * @param {flatbuffers.Builder} builder
1943  * @param {flatbuffers.Offset} posOffset
1944  */
1945 MyGame.Example.Monster.addPos = function(builder, posOffset) {
1946   builder.addFieldStruct(0, posOffset, 0);
1947 };
1948
1949 /**
1950  * @param {flatbuffers.Builder} builder
1951  * @param {number} mana
1952  */
1953 MyGame.Example.Monster.addMana = function(builder, mana) {
1954   builder.addFieldInt16(1, mana, 150);
1955 };
1956
1957 /**
1958  * @param {flatbuffers.Builder} builder
1959  * @param {number} hp
1960  */
1961 MyGame.Example.Monster.addHp = function(builder, hp) {
1962   builder.addFieldInt16(2, hp, 100);
1963 };
1964
1965 /**
1966  * @param {flatbuffers.Builder} builder
1967  * @param {flatbuffers.Offset} nameOffset
1968  */
1969 MyGame.Example.Monster.addName = function(builder, nameOffset) {
1970   builder.addFieldOffset(3, nameOffset, 0);
1971 };
1972
1973 /**
1974  * @param {flatbuffers.Builder} builder
1975  * @param {flatbuffers.Offset} inventoryOffset
1976  */
1977 MyGame.Example.Monster.addInventory = function(builder, inventoryOffset) {
1978   builder.addFieldOffset(5, inventoryOffset, 0);
1979 };
1980
1981 /**
1982  * @param {flatbuffers.Builder} builder
1983  * @param {Array.<number>} data
1984  * @returns {flatbuffers.Offset}
1985  */
1986 MyGame.Example.Monster.createInventoryVector = function(builder, data) {
1987   builder.startVector(1, data.length, 1);
1988   for (var i = data.length - 1; i >= 0; i--) {
1989     builder.addInt8(data[i]);
1990   }
1991   return builder.endVector();
1992 };
1993
1994 /**
1995  * @param {flatbuffers.Builder} builder
1996  * @param {number} numElems
1997  */
1998 MyGame.Example.Monster.startInventoryVector = function(builder, numElems) {
1999   builder.startVector(1, numElems, 1);
2000 };
2001
2002 /**
2003  * @param {flatbuffers.Builder} builder
2004  * @param {MyGame.Example.Color} color
2005  */
2006 MyGame.Example.Monster.addColor = function(builder, color) {
2007   builder.addFieldInt8(6, color, MyGame.Example.Color.Blue);
2008 };
2009
2010 /**
2011  * @param {flatbuffers.Builder} builder
2012  * @param {MyGame.Example.Any} testType
2013  */
2014 MyGame.Example.Monster.addTestType = function(builder, testType) {
2015   builder.addFieldInt8(7, testType, MyGame.Example.Any.NONE);
2016 };
2017
2018 /**
2019  * @param {flatbuffers.Builder} builder
2020  * @param {flatbuffers.Offset} testOffset
2021  */
2022 MyGame.Example.Monster.addTest = function(builder, testOffset) {
2023   builder.addFieldOffset(8, testOffset, 0);
2024 };
2025
2026 /**
2027  * @param {flatbuffers.Builder} builder
2028  * @param {flatbuffers.Offset} test4Offset
2029  */
2030 MyGame.Example.Monster.addTest4 = function(builder, test4Offset) {
2031   builder.addFieldOffset(9, test4Offset, 0);
2032 };
2033
2034 /**
2035  * @param {flatbuffers.Builder} builder
2036  * @param {number} numElems
2037  */
2038 MyGame.Example.Monster.startTest4Vector = function(builder, numElems) {
2039   builder.startVector(4, numElems, 2);
2040 };
2041
2042 /**
2043  * @param {flatbuffers.Builder} builder
2044  * @param {flatbuffers.Offset} testarrayofstringOffset
2045  */
2046 MyGame.Example.Monster.addTestarrayofstring = function(builder, testarrayofstringOffset) {
2047   builder.addFieldOffset(10, testarrayofstringOffset, 0);
2048 };
2049
2050 /**
2051  * @param {flatbuffers.Builder} builder
2052  * @param {Array.<flatbuffers.Offset>} data
2053  * @returns {flatbuffers.Offset}
2054  */
2055 MyGame.Example.Monster.createTestarrayofstringVector = function(builder, data) {
2056   builder.startVector(4, data.length, 4);
2057   for (var i = data.length - 1; i >= 0; i--) {
2058     builder.addOffset(data[i]);
2059   }
2060   return builder.endVector();
2061 };
2062
2063 /**
2064  * @param {flatbuffers.Builder} builder
2065  * @param {number} numElems
2066  */
2067 MyGame.Example.Monster.startTestarrayofstringVector = function(builder, numElems) {
2068   builder.startVector(4, numElems, 4);
2069 };
2070
2071 /**
2072  * @param {flatbuffers.Builder} builder
2073  * @param {flatbuffers.Offset} testarrayoftablesOffset
2074  */
2075 MyGame.Example.Monster.addTestarrayoftables = function(builder, testarrayoftablesOffset) {
2076   builder.addFieldOffset(11, testarrayoftablesOffset, 0);
2077 };
2078
2079 /**
2080  * @param {flatbuffers.Builder} builder
2081  * @param {Array.<flatbuffers.Offset>} data
2082  * @returns {flatbuffers.Offset}
2083  */
2084 MyGame.Example.Monster.createTestarrayoftablesVector = function(builder, data) {
2085   builder.startVector(4, data.length, 4);
2086   for (var i = data.length - 1; i >= 0; i--) {
2087     builder.addOffset(data[i]);
2088   }
2089   return builder.endVector();
2090 };
2091
2092 /**
2093  * @param {flatbuffers.Builder} builder
2094  * @param {number} numElems
2095  */
2096 MyGame.Example.Monster.startTestarrayoftablesVector = function(builder, numElems) {
2097   builder.startVector(4, numElems, 4);
2098 };
2099
2100 /**
2101  * @param {flatbuffers.Builder} builder
2102  * @param {flatbuffers.Offset} enemyOffset
2103  */
2104 MyGame.Example.Monster.addEnemy = function(builder, enemyOffset) {
2105   builder.addFieldOffset(12, enemyOffset, 0);
2106 };
2107
2108 /**
2109  * @param {flatbuffers.Builder} builder
2110  * @param {flatbuffers.Offset} testnestedflatbufferOffset
2111  */
2112 MyGame.Example.Monster.addTestnestedflatbuffer = function(builder, testnestedflatbufferOffset) {
2113   builder.addFieldOffset(13, testnestedflatbufferOffset, 0);
2114 };
2115
2116 /**
2117  * @param {flatbuffers.Builder} builder
2118  * @param {Array.<number>} data
2119  * @returns {flatbuffers.Offset}
2120  */
2121 MyGame.Example.Monster.createTestnestedflatbufferVector = function(builder, data) {
2122   builder.startVector(1, data.length, 1);
2123   for (var i = data.length - 1; i >= 0; i--) {
2124     builder.addInt8(data[i]);
2125   }
2126   return builder.endVector();
2127 };
2128
2129 /**
2130  * @param {flatbuffers.Builder} builder
2131  * @param {number} numElems
2132  */
2133 MyGame.Example.Monster.startTestnestedflatbufferVector = function(builder, numElems) {
2134   builder.startVector(1, numElems, 1);
2135 };
2136
2137 /**
2138  * @param {flatbuffers.Builder} builder
2139  * @param {flatbuffers.Offset} testemptyOffset
2140  */
2141 MyGame.Example.Monster.addTestempty = function(builder, testemptyOffset) {
2142   builder.addFieldOffset(14, testemptyOffset, 0);
2143 };
2144
2145 /**
2146  * @param {flatbuffers.Builder} builder
2147  * @param {boolean} testbool
2148  */
2149 MyGame.Example.Monster.addTestbool = function(builder, testbool) {
2150   builder.addFieldInt8(15, +testbool, +false);
2151 };
2152
2153 /**
2154  * @param {flatbuffers.Builder} builder
2155  * @param {number} testhashs32Fnv1
2156  */
2157 MyGame.Example.Monster.addTesthashs32Fnv1 = function(builder, testhashs32Fnv1) {
2158   builder.addFieldInt32(16, testhashs32Fnv1, 0);
2159 };
2160
2161 /**
2162  * @param {flatbuffers.Builder} builder
2163  * @param {number} testhashu32Fnv1
2164  */
2165 MyGame.Example.Monster.addTesthashu32Fnv1 = function(builder, testhashu32Fnv1) {
2166   builder.addFieldInt32(17, testhashu32Fnv1, 0);
2167 };
2168
2169 /**
2170  * @param {flatbuffers.Builder} builder
2171  * @param {flatbuffers.Long} testhashs64Fnv1
2172  */
2173 MyGame.Example.Monster.addTesthashs64Fnv1 = function(builder, testhashs64Fnv1) {
2174   builder.addFieldInt64(18, testhashs64Fnv1, builder.createLong(0, 0));
2175 };
2176
2177 /**
2178  * @param {flatbuffers.Builder} builder
2179  * @param {flatbuffers.Long} testhashu64Fnv1
2180  */
2181 MyGame.Example.Monster.addTesthashu64Fnv1 = function(builder, testhashu64Fnv1) {
2182   builder.addFieldInt64(19, testhashu64Fnv1, builder.createLong(0, 0));
2183 };
2184
2185 /**
2186  * @param {flatbuffers.Builder} builder
2187  * @param {number} testhashs32Fnv1a
2188  */
2189 MyGame.Example.Monster.addTesthashs32Fnv1a = function(builder, testhashs32Fnv1a) {
2190   builder.addFieldInt32(20, testhashs32Fnv1a, 0);
2191 };
2192
2193 /**
2194  * @param {flatbuffers.Builder} builder
2195  * @param {number} testhashu32Fnv1a
2196  */
2197 MyGame.Example.Monster.addTesthashu32Fnv1a = function(builder, testhashu32Fnv1a) {
2198   builder.addFieldInt32(21, testhashu32Fnv1a, 0);
2199 };
2200
2201 /**
2202  * @param {flatbuffers.Builder} builder
2203  * @param {flatbuffers.Long} testhashs64Fnv1a
2204  */
2205 MyGame.Example.Monster.addTesthashs64Fnv1a = function(builder, testhashs64Fnv1a) {
2206   builder.addFieldInt64(22, testhashs64Fnv1a, builder.createLong(0, 0));
2207 };
2208
2209 /**
2210  * @param {flatbuffers.Builder} builder
2211  * @param {flatbuffers.Long} testhashu64Fnv1a
2212  */
2213 MyGame.Example.Monster.addTesthashu64Fnv1a = function(builder, testhashu64Fnv1a) {
2214   builder.addFieldInt64(23, testhashu64Fnv1a, builder.createLong(0, 0));
2215 };
2216
2217 /**
2218  * @param {flatbuffers.Builder} builder
2219  * @param {flatbuffers.Offset} testarrayofboolsOffset
2220  */
2221 MyGame.Example.Monster.addTestarrayofbools = function(builder, testarrayofboolsOffset) {
2222   builder.addFieldOffset(24, testarrayofboolsOffset, 0);
2223 };
2224
2225 /**
2226  * @param {flatbuffers.Builder} builder
2227  * @param {Array.<boolean>} data
2228  * @returns {flatbuffers.Offset}
2229  */
2230 MyGame.Example.Monster.createTestarrayofboolsVector = function(builder, data) {
2231   builder.startVector(1, data.length, 1);
2232   for (var i = data.length - 1; i >= 0; i--) {
2233     builder.addInt8(+data[i]);
2234   }
2235   return builder.endVector();
2236 };
2237
2238 /**
2239  * @param {flatbuffers.Builder} builder
2240  * @param {number} numElems
2241  */
2242 MyGame.Example.Monster.startTestarrayofboolsVector = function(builder, numElems) {
2243   builder.startVector(1, numElems, 1);
2244 };
2245
2246 /**
2247  * @param {flatbuffers.Builder} builder
2248  * @param {number} testf
2249  */
2250 MyGame.Example.Monster.addTestf = function(builder, testf) {
2251   builder.addFieldFloat32(25, testf, 3.14159);
2252 };
2253
2254 /**
2255  * @param {flatbuffers.Builder} builder
2256  * @param {number} testf2
2257  */
2258 MyGame.Example.Monster.addTestf2 = function(builder, testf2) {
2259   builder.addFieldFloat32(26, testf2, 3.0);
2260 };
2261
2262 /**
2263  * @param {flatbuffers.Builder} builder
2264  * @param {number} testf3
2265  */
2266 MyGame.Example.Monster.addTestf3 = function(builder, testf3) {
2267   builder.addFieldFloat32(27, testf3, 0.0);
2268 };
2269
2270 /**
2271  * @param {flatbuffers.Builder} builder
2272  * @param {flatbuffers.Offset} testarrayofstring2Offset
2273  */
2274 MyGame.Example.Monster.addTestarrayofstring2 = function(builder, testarrayofstring2Offset) {
2275   builder.addFieldOffset(28, testarrayofstring2Offset, 0);
2276 };
2277
2278 /**
2279  * @param {flatbuffers.Builder} builder
2280  * @param {Array.<flatbuffers.Offset>} data
2281  * @returns {flatbuffers.Offset}
2282  */
2283 MyGame.Example.Monster.createTestarrayofstring2Vector = function(builder, data) {
2284   builder.startVector(4, data.length, 4);
2285   for (var i = data.length - 1; i >= 0; i--) {
2286     builder.addOffset(data[i]);
2287   }
2288   return builder.endVector();
2289 };
2290
2291 /**
2292  * @param {flatbuffers.Builder} builder
2293  * @param {number} numElems
2294  */
2295 MyGame.Example.Monster.startTestarrayofstring2Vector = function(builder, numElems) {
2296   builder.startVector(4, numElems, 4);
2297 };
2298
2299 /**
2300  * @param {flatbuffers.Builder} builder
2301  * @param {flatbuffers.Offset} testarrayofsortedstructOffset
2302  */
2303 MyGame.Example.Monster.addTestarrayofsortedstruct = function(builder, testarrayofsortedstructOffset) {
2304   builder.addFieldOffset(29, testarrayofsortedstructOffset, 0);
2305 };
2306
2307 /**
2308  * @param {flatbuffers.Builder} builder
2309  * @param {number} numElems
2310  */
2311 MyGame.Example.Monster.startTestarrayofsortedstructVector = function(builder, numElems) {
2312   builder.startVector(8, numElems, 4);
2313 };
2314
2315 /**
2316  * @param {flatbuffers.Builder} builder
2317  * @param {flatbuffers.Offset} flexOffset
2318  */
2319 MyGame.Example.Monster.addFlex = function(builder, flexOffset) {
2320   builder.addFieldOffset(30, flexOffset, 0);
2321 };
2322
2323 /**
2324  * @param {flatbuffers.Builder} builder
2325  * @param {Array.<number>} data
2326  * @returns {flatbuffers.Offset}
2327  */
2328 MyGame.Example.Monster.createFlexVector = function(builder, data) {
2329   builder.startVector(1, data.length, 1);
2330   for (var i = data.length - 1; i >= 0; i--) {
2331     builder.addInt8(data[i]);
2332   }
2333   return builder.endVector();
2334 };
2335
2336 /**
2337  * @param {flatbuffers.Builder} builder
2338  * @param {number} numElems
2339  */
2340 MyGame.Example.Monster.startFlexVector = function(builder, numElems) {
2341   builder.startVector(1, numElems, 1);
2342 };
2343
2344 /**
2345  * @param {flatbuffers.Builder} builder
2346  * @param {flatbuffers.Offset} test5Offset
2347  */
2348 MyGame.Example.Monster.addTest5 = function(builder, test5Offset) {
2349   builder.addFieldOffset(31, test5Offset, 0);
2350 };
2351
2352 /**
2353  * @param {flatbuffers.Builder} builder
2354  * @param {number} numElems
2355  */
2356 MyGame.Example.Monster.startTest5Vector = function(builder, numElems) {
2357   builder.startVector(4, numElems, 2);
2358 };
2359
2360 /**
2361  * @param {flatbuffers.Builder} builder
2362  * @param {flatbuffers.Offset} vectorOfLongsOffset
2363  */
2364 MyGame.Example.Monster.addVectorOfLongs = function(builder, vectorOfLongsOffset) {
2365   builder.addFieldOffset(32, vectorOfLongsOffset, 0);
2366 };
2367
2368 /**
2369  * @param {flatbuffers.Builder} builder
2370  * @param {Array.<flatbuffers.Long>} data
2371  * @returns {flatbuffers.Offset}
2372  */
2373 MyGame.Example.Monster.createVectorOfLongsVector = function(builder, data) {
2374   builder.startVector(8, data.length, 8);
2375   for (var i = data.length - 1; i >= 0; i--) {
2376     builder.addInt64(data[i]);
2377   }
2378   return builder.endVector();
2379 };
2380
2381 /**
2382  * @param {flatbuffers.Builder} builder
2383  * @param {number} numElems
2384  */
2385 MyGame.Example.Monster.startVectorOfLongsVector = function(builder, numElems) {
2386   builder.startVector(8, numElems, 8);
2387 };
2388
2389 /**
2390  * @param {flatbuffers.Builder} builder
2391  * @param {flatbuffers.Offset} vectorOfDoublesOffset
2392  */
2393 MyGame.Example.Monster.addVectorOfDoubles = function(builder, vectorOfDoublesOffset) {
2394   builder.addFieldOffset(33, vectorOfDoublesOffset, 0);
2395 };
2396
2397 /**
2398  * @param {flatbuffers.Builder} builder
2399  * @param {Array.<number>} data
2400  * @returns {flatbuffers.Offset}
2401  */
2402 MyGame.Example.Monster.createVectorOfDoublesVector = function(builder, data) {
2403   builder.startVector(8, data.length, 8);
2404   for (var i = data.length - 1; i >= 0; i--) {
2405     builder.addFloat64(data[i]);
2406   }
2407   return builder.endVector();
2408 };
2409
2410 /**
2411  * @param {flatbuffers.Builder} builder
2412  * @param {number} numElems
2413  */
2414 MyGame.Example.Monster.startVectorOfDoublesVector = function(builder, numElems) {
2415   builder.startVector(8, numElems, 8);
2416 };
2417
2418 /**
2419  * @param {flatbuffers.Builder} builder
2420  * @param {flatbuffers.Offset} parentNamespaceTestOffset
2421  */
2422 MyGame.Example.Monster.addParentNamespaceTest = function(builder, parentNamespaceTestOffset) {
2423   builder.addFieldOffset(34, parentNamespaceTestOffset, 0);
2424 };
2425
2426 /**
2427  * @param {flatbuffers.Builder} builder
2428  * @param {flatbuffers.Offset} vectorOfReferrablesOffset
2429  */
2430 MyGame.Example.Monster.addVectorOfReferrables = function(builder, vectorOfReferrablesOffset) {
2431   builder.addFieldOffset(35, vectorOfReferrablesOffset, 0);
2432 };
2433
2434 /**
2435  * @param {flatbuffers.Builder} builder
2436  * @param {Array.<flatbuffers.Offset>} data
2437  * @returns {flatbuffers.Offset}
2438  */
2439 MyGame.Example.Monster.createVectorOfReferrablesVector = function(builder, data) {
2440   builder.startVector(4, data.length, 4);
2441   for (var i = data.length - 1; i >= 0; i--) {
2442     builder.addOffset(data[i]);
2443   }
2444   return builder.endVector();
2445 };
2446
2447 /**
2448  * @param {flatbuffers.Builder} builder
2449  * @param {number} numElems
2450  */
2451 MyGame.Example.Monster.startVectorOfReferrablesVector = function(builder, numElems) {
2452   builder.startVector(4, numElems, 4);
2453 };
2454
2455 /**
2456  * @param {flatbuffers.Builder} builder
2457  * @param {flatbuffers.Long} singleWeakReference
2458  */
2459 MyGame.Example.Monster.addSingleWeakReference = function(builder, singleWeakReference) {
2460   builder.addFieldInt64(36, singleWeakReference, builder.createLong(0, 0));
2461 };
2462
2463 /**
2464  * @param {flatbuffers.Builder} builder
2465  * @param {flatbuffers.Offset} vectorOfWeakReferencesOffset
2466  */
2467 MyGame.Example.Monster.addVectorOfWeakReferences = function(builder, vectorOfWeakReferencesOffset) {
2468   builder.addFieldOffset(37, vectorOfWeakReferencesOffset, 0);
2469 };
2470
2471 /**
2472  * @param {flatbuffers.Builder} builder
2473  * @param {Array.<flatbuffers.Long>} data
2474  * @returns {flatbuffers.Offset}
2475  */
2476 MyGame.Example.Monster.createVectorOfWeakReferencesVector = function(builder, data) {
2477   builder.startVector(8, data.length, 8);
2478   for (var i = data.length - 1; i >= 0; i--) {
2479     builder.addInt64(data[i]);
2480   }
2481   return builder.endVector();
2482 };
2483
2484 /**
2485  * @param {flatbuffers.Builder} builder
2486  * @param {number} numElems
2487  */
2488 MyGame.Example.Monster.startVectorOfWeakReferencesVector = function(builder, numElems) {
2489   builder.startVector(8, numElems, 8);
2490 };
2491
2492 /**
2493  * @param {flatbuffers.Builder} builder
2494  * @param {flatbuffers.Offset} vectorOfStrongReferrablesOffset
2495  */
2496 MyGame.Example.Monster.addVectorOfStrongReferrables = function(builder, vectorOfStrongReferrablesOffset) {
2497   builder.addFieldOffset(38, vectorOfStrongReferrablesOffset, 0);
2498 };
2499
2500 /**
2501  * @param {flatbuffers.Builder} builder
2502  * @param {Array.<flatbuffers.Offset>} data
2503  * @returns {flatbuffers.Offset}
2504  */
2505 MyGame.Example.Monster.createVectorOfStrongReferrablesVector = function(builder, data) {
2506   builder.startVector(4, data.length, 4);
2507   for (var i = data.length - 1; i >= 0; i--) {
2508     builder.addOffset(data[i]);
2509   }
2510   return builder.endVector();
2511 };
2512
2513 /**
2514  * @param {flatbuffers.Builder} builder
2515  * @param {number} numElems
2516  */
2517 MyGame.Example.Monster.startVectorOfStrongReferrablesVector = function(builder, numElems) {
2518   builder.startVector(4, numElems, 4);
2519 };
2520
2521 /**
2522  * @param {flatbuffers.Builder} builder
2523  * @param {flatbuffers.Long} coOwningReference
2524  */
2525 MyGame.Example.Monster.addCoOwningReference = function(builder, coOwningReference) {
2526   builder.addFieldInt64(39, coOwningReference, builder.createLong(0, 0));
2527 };
2528
2529 /**
2530  * @param {flatbuffers.Builder} builder
2531  * @param {flatbuffers.Offset} vectorOfCoOwningReferencesOffset
2532  */
2533 MyGame.Example.Monster.addVectorOfCoOwningReferences = function(builder, vectorOfCoOwningReferencesOffset) {
2534   builder.addFieldOffset(40, vectorOfCoOwningReferencesOffset, 0);
2535 };
2536
2537 /**
2538  * @param {flatbuffers.Builder} builder
2539  * @param {Array.<flatbuffers.Long>} data
2540  * @returns {flatbuffers.Offset}
2541  */
2542 MyGame.Example.Monster.createVectorOfCoOwningReferencesVector = function(builder, data) {
2543   builder.startVector(8, data.length, 8);
2544   for (var i = data.length - 1; i >= 0; i--) {
2545     builder.addInt64(data[i]);
2546   }
2547   return builder.endVector();
2548 };
2549
2550 /**
2551  * @param {flatbuffers.Builder} builder
2552  * @param {number} numElems
2553  */
2554 MyGame.Example.Monster.startVectorOfCoOwningReferencesVector = function(builder, numElems) {
2555   builder.startVector(8, numElems, 8);
2556 };
2557
2558 /**
2559  * @param {flatbuffers.Builder} builder
2560  * @param {flatbuffers.Long} nonOwningReference
2561  */
2562 MyGame.Example.Monster.addNonOwningReference = function(builder, nonOwningReference) {
2563   builder.addFieldInt64(41, nonOwningReference, builder.createLong(0, 0));
2564 };
2565
2566 /**
2567  * @param {flatbuffers.Builder} builder
2568  * @param {flatbuffers.Offset} vectorOfNonOwningReferencesOffset
2569  */
2570 MyGame.Example.Monster.addVectorOfNonOwningReferences = function(builder, vectorOfNonOwningReferencesOffset) {
2571   builder.addFieldOffset(42, vectorOfNonOwningReferencesOffset, 0);
2572 };
2573
2574 /**
2575  * @param {flatbuffers.Builder} builder
2576  * @param {Array.<flatbuffers.Long>} data
2577  * @returns {flatbuffers.Offset}
2578  */
2579 MyGame.Example.Monster.createVectorOfNonOwningReferencesVector = function(builder, data) {
2580   builder.startVector(8, data.length, 8);
2581   for (var i = data.length - 1; i >= 0; i--) {
2582     builder.addInt64(data[i]);
2583   }
2584   return builder.endVector();
2585 };
2586
2587 /**
2588  * @param {flatbuffers.Builder} builder
2589  * @param {number} numElems
2590  */
2591 MyGame.Example.Monster.startVectorOfNonOwningReferencesVector = function(builder, numElems) {
2592   builder.startVector(8, numElems, 8);
2593 };
2594
2595 /**
2596  * @param {flatbuffers.Builder} builder
2597  * @param {MyGame.Example.AnyUniqueAliases} anyUniqueType
2598  */
2599 MyGame.Example.Monster.addAnyUniqueType = function(builder, anyUniqueType) {
2600   builder.addFieldInt8(43, anyUniqueType, MyGame.Example.AnyUniqueAliases.NONE);
2601 };
2602
2603 /**
2604  * @param {flatbuffers.Builder} builder
2605  * @param {flatbuffers.Offset} anyUniqueOffset
2606  */
2607 MyGame.Example.Monster.addAnyUnique = function(builder, anyUniqueOffset) {
2608   builder.addFieldOffset(44, anyUniqueOffset, 0);
2609 };
2610
2611 /**
2612  * @param {flatbuffers.Builder} builder
2613  * @param {MyGame.Example.AnyAmbiguousAliases} anyAmbiguousType
2614  */
2615 MyGame.Example.Monster.addAnyAmbiguousType = function(builder, anyAmbiguousType) {
2616   builder.addFieldInt8(45, anyAmbiguousType, MyGame.Example.AnyAmbiguousAliases.NONE);
2617 };
2618
2619 /**
2620  * @param {flatbuffers.Builder} builder
2621  * @param {flatbuffers.Offset} anyAmbiguousOffset
2622  */
2623 MyGame.Example.Monster.addAnyAmbiguous = function(builder, anyAmbiguousOffset) {
2624   builder.addFieldOffset(46, anyAmbiguousOffset, 0);
2625 };
2626
2627 /**
2628  * @param {flatbuffers.Builder} builder
2629  * @param {flatbuffers.Offset} vectorOfEnumsOffset
2630  */
2631 MyGame.Example.Monster.addVectorOfEnums = function(builder, vectorOfEnumsOffset) {
2632   builder.addFieldOffset(47, vectorOfEnumsOffset, 0);
2633 };
2634
2635 /**
2636  * @param {flatbuffers.Builder} builder
2637  * @param {Array.<MyGame.Example.Color>} data
2638  * @returns {flatbuffers.Offset}
2639  */
2640 MyGame.Example.Monster.createVectorOfEnumsVector = function(builder, data) {
2641   builder.startVector(1, data.length, 1);
2642   for (var i = data.length - 1; i >= 0; i--) {
2643     builder.addInt8(data[i]);
2644   }
2645   return builder.endVector();
2646 };
2647
2648 /**
2649  * @param {flatbuffers.Builder} builder
2650  * @param {number} numElems
2651  */
2652 MyGame.Example.Monster.startVectorOfEnumsVector = function(builder, numElems) {
2653   builder.startVector(1, numElems, 1);
2654 };
2655
2656 /**
2657  * @param {flatbuffers.Builder} builder
2658  * @param {MyGame.Example.Race} signedEnum
2659  */
2660 MyGame.Example.Monster.addSignedEnum = function(builder, signedEnum) {
2661   builder.addFieldInt8(48, signedEnum, MyGame.Example.Race.None);
2662 };
2663
2664 /**
2665  * @param {flatbuffers.Builder} builder
2666  * @returns {flatbuffers.Offset}
2667  */
2668 MyGame.Example.Monster.endMonster = function(builder) {
2669   var offset = builder.endObject();
2670   builder.requiredField(offset, 10); // name
2671   return offset;
2672 };
2673
2674 /**
2675  * @param {flatbuffers.Builder} builder
2676  * @param {flatbuffers.Offset} offset
2677  */
2678 MyGame.Example.Monster.finishMonsterBuffer = function(builder, offset) {
2679   builder.finish(offset, 'MONS');
2680 };
2681
2682 /**
2683  * @param {flatbuffers.Builder} builder
2684  * @param {flatbuffers.Offset} offset
2685  */
2686 MyGame.Example.Monster.finishSizePrefixedMonsterBuffer = function(builder, offset) {
2687   builder.finish(offset, 'MONS', true);
2688 };
2689
2690 /**
2691  * @param {flatbuffers.Builder} builder
2692  * @param {flatbuffers.Offset} posOffset
2693  * @param {number} mana
2694  * @param {number} hp
2695  * @param {flatbuffers.Offset} nameOffset
2696  * @param {flatbuffers.Offset} inventoryOffset
2697  * @param {MyGame.Example.Color} color
2698  * @param {MyGame.Example.Any} testType
2699  * @param {flatbuffers.Offset} testOffset
2700  * @param {flatbuffers.Offset} test4Offset
2701  * @param {flatbuffers.Offset} testarrayofstringOffset
2702  * @param {flatbuffers.Offset} testarrayoftablesOffset
2703  * @param {flatbuffers.Offset} enemyOffset
2704  * @param {flatbuffers.Offset} testnestedflatbufferOffset
2705  * @param {flatbuffers.Offset} testemptyOffset
2706  * @param {boolean} testbool
2707  * @param {number} testhashs32Fnv1
2708  * @param {number} testhashu32Fnv1
2709  * @param {flatbuffers.Long} testhashs64Fnv1
2710  * @param {flatbuffers.Long} testhashu64Fnv1
2711  * @param {number} testhashs32Fnv1a
2712  * @param {number} testhashu32Fnv1a
2713  * @param {flatbuffers.Long} testhashs64Fnv1a
2714  * @param {flatbuffers.Long} testhashu64Fnv1a
2715  * @param {flatbuffers.Offset} testarrayofboolsOffset
2716  * @param {number} testf
2717  * @param {number} testf2
2718  * @param {number} testf3
2719  * @param {flatbuffers.Offset} testarrayofstring2Offset
2720  * @param {flatbuffers.Offset} testarrayofsortedstructOffset
2721  * @param {flatbuffers.Offset} flexOffset
2722  * @param {flatbuffers.Offset} test5Offset
2723  * @param {flatbuffers.Offset} vectorOfLongsOffset
2724  * @param {flatbuffers.Offset} vectorOfDoublesOffset
2725  * @param {flatbuffers.Offset} parentNamespaceTestOffset
2726  * @param {flatbuffers.Offset} vectorOfReferrablesOffset
2727  * @param {flatbuffers.Long} singleWeakReference
2728  * @param {flatbuffers.Offset} vectorOfWeakReferencesOffset
2729  * @param {flatbuffers.Offset} vectorOfStrongReferrablesOffset
2730  * @param {flatbuffers.Long} coOwningReference
2731  * @param {flatbuffers.Offset} vectorOfCoOwningReferencesOffset
2732  * @param {flatbuffers.Long} nonOwningReference
2733  * @param {flatbuffers.Offset} vectorOfNonOwningReferencesOffset
2734  * @param {MyGame.Example.AnyUniqueAliases} anyUniqueType
2735  * @param {flatbuffers.Offset} anyUniqueOffset
2736  * @param {MyGame.Example.AnyAmbiguousAliases} anyAmbiguousType
2737  * @param {flatbuffers.Offset} anyAmbiguousOffset
2738  * @param {flatbuffers.Offset} vectorOfEnumsOffset
2739  * @param {MyGame.Example.Race} signedEnum
2740  * @returns {flatbuffers.Offset}
2741  */
2742 MyGame.Example.Monster.createMonster = function(builder, posOffset, mana, hp, nameOffset, inventoryOffset, color, testType, testOffset, test4Offset, testarrayofstringOffset, testarrayoftablesOffset, enemyOffset, testnestedflatbufferOffset, testemptyOffset, testbool, testhashs32Fnv1, testhashu32Fnv1, testhashs64Fnv1, testhashu64Fnv1, testhashs32Fnv1a, testhashu32Fnv1a, testhashs64Fnv1a, testhashu64Fnv1a, testarrayofboolsOffset, testf, testf2, testf3, testarrayofstring2Offset, testarrayofsortedstructOffset, flexOffset, test5Offset, vectorOfLongsOffset, vectorOfDoublesOffset, parentNamespaceTestOffset, vectorOfReferrablesOffset, singleWeakReference, vectorOfWeakReferencesOffset, vectorOfStrongReferrablesOffset, coOwningReference, vectorOfCoOwningReferencesOffset, nonOwningReference, vectorOfNonOwningReferencesOffset, anyUniqueType, anyUniqueOffset, anyAmbiguousType, anyAmbiguousOffset, vectorOfEnumsOffset, signedEnum) {
2743   MyGame.Example.Monster.startMonster(builder);
2744   MyGame.Example.Monster.addPos(builder, posOffset);
2745   MyGame.Example.Monster.addMana(builder, mana);
2746   MyGame.Example.Monster.addHp(builder, hp);
2747   MyGame.Example.Monster.addName(builder, nameOffset);
2748   MyGame.Example.Monster.addInventory(builder, inventoryOffset);
2749   MyGame.Example.Monster.addColor(builder, color);
2750   MyGame.Example.Monster.addTestType(builder, testType);
2751   MyGame.Example.Monster.addTest(builder, testOffset);
2752   MyGame.Example.Monster.addTest4(builder, test4Offset);
2753   MyGame.Example.Monster.addTestarrayofstring(builder, testarrayofstringOffset);
2754   MyGame.Example.Monster.addTestarrayoftables(builder, testarrayoftablesOffset);
2755   MyGame.Example.Monster.addEnemy(builder, enemyOffset);
2756   MyGame.Example.Monster.addTestnestedflatbuffer(builder, testnestedflatbufferOffset);
2757   MyGame.Example.Monster.addTestempty(builder, testemptyOffset);
2758   MyGame.Example.Monster.addTestbool(builder, testbool);
2759   MyGame.Example.Monster.addTesthashs32Fnv1(builder, testhashs32Fnv1);
2760   MyGame.Example.Monster.addTesthashu32Fnv1(builder, testhashu32Fnv1);
2761   MyGame.Example.Monster.addTesthashs64Fnv1(builder, testhashs64Fnv1);
2762   MyGame.Example.Monster.addTesthashu64Fnv1(builder, testhashu64Fnv1);
2763   MyGame.Example.Monster.addTesthashs32Fnv1a(builder, testhashs32Fnv1a);
2764   MyGame.Example.Monster.addTesthashu32Fnv1a(builder, testhashu32Fnv1a);
2765   MyGame.Example.Monster.addTesthashs64Fnv1a(builder, testhashs64Fnv1a);
2766   MyGame.Example.Monster.addTesthashu64Fnv1a(builder, testhashu64Fnv1a);
2767   MyGame.Example.Monster.addTestarrayofbools(builder, testarrayofboolsOffset);
2768   MyGame.Example.Monster.addTestf(builder, testf);
2769   MyGame.Example.Monster.addTestf2(builder, testf2);
2770   MyGame.Example.Monster.addTestf3(builder, testf3);
2771   MyGame.Example.Monster.addTestarrayofstring2(builder, testarrayofstring2Offset);
2772   MyGame.Example.Monster.addTestarrayofsortedstruct(builder, testarrayofsortedstructOffset);
2773   MyGame.Example.Monster.addFlex(builder, flexOffset);
2774   MyGame.Example.Monster.addTest5(builder, test5Offset);
2775   MyGame.Example.Monster.addVectorOfLongs(builder, vectorOfLongsOffset);
2776   MyGame.Example.Monster.addVectorOfDoubles(builder, vectorOfDoublesOffset);
2777   MyGame.Example.Monster.addParentNamespaceTest(builder, parentNamespaceTestOffset);
2778   MyGame.Example.Monster.addVectorOfReferrables(builder, vectorOfReferrablesOffset);
2779   MyGame.Example.Monster.addSingleWeakReference(builder, singleWeakReference);
2780   MyGame.Example.Monster.addVectorOfWeakReferences(builder, vectorOfWeakReferencesOffset);
2781   MyGame.Example.Monster.addVectorOfStrongReferrables(builder, vectorOfStrongReferrablesOffset);
2782   MyGame.Example.Monster.addCoOwningReference(builder, coOwningReference);
2783   MyGame.Example.Monster.addVectorOfCoOwningReferences(builder, vectorOfCoOwningReferencesOffset);
2784   MyGame.Example.Monster.addNonOwningReference(builder, nonOwningReference);
2785   MyGame.Example.Monster.addVectorOfNonOwningReferences(builder, vectorOfNonOwningReferencesOffset);
2786   MyGame.Example.Monster.addAnyUniqueType(builder, anyUniqueType);
2787   MyGame.Example.Monster.addAnyUnique(builder, anyUniqueOffset);
2788   MyGame.Example.Monster.addAnyAmbiguousType(builder, anyAmbiguousType);
2789   MyGame.Example.Monster.addAnyAmbiguous(builder, anyAmbiguousOffset);
2790   MyGame.Example.Monster.addVectorOfEnums(builder, vectorOfEnumsOffset);
2791   MyGame.Example.Monster.addSignedEnum(builder, signedEnum);
2792   return MyGame.Example.Monster.endMonster(builder);
2793 }
2794
2795 /**
2796  * @constructor
2797  */
2798 MyGame.Example.TypeAliases = function() {
2799   /**
2800    * @type {flatbuffers.ByteBuffer}
2801    */
2802   this.bb = null;
2803
2804   /**
2805    * @type {number}
2806    */
2807   this.bb_pos = 0;
2808 };
2809
2810 /**
2811  * @param {number} i
2812  * @param {flatbuffers.ByteBuffer} bb
2813  * @returns {MyGame.Example.TypeAliases}
2814  */
2815 MyGame.Example.TypeAliases.prototype.__init = function(i, bb) {
2816   this.bb_pos = i;
2817   this.bb = bb;
2818   return this;
2819 };
2820
2821 /**
2822  * @param {flatbuffers.ByteBuffer} bb
2823  * @param {MyGame.Example.TypeAliases=} obj
2824  * @returns {MyGame.Example.TypeAliases}
2825  */
2826 MyGame.Example.TypeAliases.getRootAsTypeAliases = function(bb, obj) {
2827   return (obj || new MyGame.Example.TypeAliases).__init(bb.readInt32(bb.position()) + bb.position(), bb);
2828 };
2829
2830 /**
2831  * @param {flatbuffers.ByteBuffer} bb
2832  * @param {MyGame.Example.TypeAliases=} obj
2833  * @returns {MyGame.Example.TypeAliases}
2834  */
2835 MyGame.Example.TypeAliases.getSizePrefixedRootAsTypeAliases = function(bb, obj) {
2836   return (obj || new MyGame.Example.TypeAliases).__init(bb.readInt32(bb.position()) + bb.position(), bb);
2837 };
2838
2839 /**
2840  * @returns {number}
2841  */
2842 MyGame.Example.TypeAliases.prototype.i8 = function() {
2843   var offset = this.bb.__offset(this.bb_pos, 4);
2844   return offset ? this.bb.readInt8(this.bb_pos + offset) : 0;
2845 };
2846
2847 /**
2848  * @param {number} value
2849  * @returns {boolean}
2850  */
2851 MyGame.Example.TypeAliases.prototype.mutate_i8 = function(value) {
2852   var offset = this.bb.__offset(this.bb_pos, 4);
2853
2854   if (offset === 0) {
2855     return false;
2856   }
2857
2858   this.bb.writeInt8(this.bb_pos + offset, value);
2859   return true;
2860 };
2861
2862 /**
2863  * @returns {number}
2864  */
2865 MyGame.Example.TypeAliases.prototype.u8 = function() {
2866   var offset = this.bb.__offset(this.bb_pos, 6);
2867   return offset ? this.bb.readUint8(this.bb_pos + offset) : 0;
2868 };
2869
2870 /**
2871  * @param {number} value
2872  * @returns {boolean}
2873  */
2874 MyGame.Example.TypeAliases.prototype.mutate_u8 = function(value) {
2875   var offset = this.bb.__offset(this.bb_pos, 6);
2876
2877   if (offset === 0) {
2878     return false;
2879   }
2880
2881   this.bb.writeUint8(this.bb_pos + offset, value);
2882   return true;
2883 };
2884
2885 /**
2886  * @returns {number}
2887  */
2888 MyGame.Example.TypeAliases.prototype.i16 = function() {
2889   var offset = this.bb.__offset(this.bb_pos, 8);
2890   return offset ? this.bb.readInt16(this.bb_pos + offset) : 0;
2891 };
2892
2893 /**
2894  * @param {number} value
2895  * @returns {boolean}
2896  */
2897 MyGame.Example.TypeAliases.prototype.mutate_i16 = function(value) {
2898   var offset = this.bb.__offset(this.bb_pos, 8);
2899
2900   if (offset === 0) {
2901     return false;
2902   }
2903
2904   this.bb.writeInt16(this.bb_pos + offset, value);
2905   return true;
2906 };
2907
2908 /**
2909  * @returns {number}
2910  */
2911 MyGame.Example.TypeAliases.prototype.u16 = function() {
2912   var offset = this.bb.__offset(this.bb_pos, 10);
2913   return offset ? this.bb.readUint16(this.bb_pos + offset) : 0;
2914 };
2915
2916 /**
2917  * @param {number} value
2918  * @returns {boolean}
2919  */
2920 MyGame.Example.TypeAliases.prototype.mutate_u16 = function(value) {
2921   var offset = this.bb.__offset(this.bb_pos, 10);
2922
2923   if (offset === 0) {
2924     return false;
2925   }
2926
2927   this.bb.writeUint16(this.bb_pos + offset, value);
2928   return true;
2929 };
2930
2931 /**
2932  * @returns {number}
2933  */
2934 MyGame.Example.TypeAliases.prototype.i32 = function() {
2935   var offset = this.bb.__offset(this.bb_pos, 12);
2936   return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
2937 };
2938
2939 /**
2940  * @param {number} value
2941  * @returns {boolean}
2942  */
2943 MyGame.Example.TypeAliases.prototype.mutate_i32 = function(value) {
2944   var offset = this.bb.__offset(this.bb_pos, 12);
2945
2946   if (offset === 0) {
2947     return false;
2948   }
2949
2950   this.bb.writeInt32(this.bb_pos + offset, value);
2951   return true;
2952 };
2953
2954 /**
2955  * @returns {number}
2956  */
2957 MyGame.Example.TypeAliases.prototype.u32 = function() {
2958   var offset = this.bb.__offset(this.bb_pos, 14);
2959   return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
2960 };
2961
2962 /**
2963  * @param {number} value
2964  * @returns {boolean}
2965  */
2966 MyGame.Example.TypeAliases.prototype.mutate_u32 = function(value) {
2967   var offset = this.bb.__offset(this.bb_pos, 14);
2968
2969   if (offset === 0) {
2970     return false;
2971   }
2972
2973   this.bb.writeUint32(this.bb_pos + offset, value);
2974   return true;
2975 };
2976
2977 /**
2978  * @returns {flatbuffers.Long}
2979  */
2980 MyGame.Example.TypeAliases.prototype.i64 = function() {
2981   var offset = this.bb.__offset(this.bb_pos, 16);
2982   return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
2983 };
2984
2985 /**
2986  * @param {flatbuffers.Long} value
2987  * @returns {boolean}
2988  */
2989 MyGame.Example.TypeAliases.prototype.mutate_i64 = function(value) {
2990   var offset = this.bb.__offset(this.bb_pos, 16);
2991
2992   if (offset === 0) {
2993     return false;
2994   }
2995
2996   this.bb.writeInt64(this.bb_pos + offset, value);
2997   return true;
2998 };
2999
3000 /**
3001  * @returns {flatbuffers.Long}
3002  */
3003 MyGame.Example.TypeAliases.prototype.u64 = function() {
3004   var offset = this.bb.__offset(this.bb_pos, 18);
3005   return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0);
3006 };
3007
3008 /**
3009  * @param {flatbuffers.Long} value
3010  * @returns {boolean}
3011  */
3012 MyGame.Example.TypeAliases.prototype.mutate_u64 = function(value) {
3013   var offset = this.bb.__offset(this.bb_pos, 18);
3014
3015   if (offset === 0) {
3016     return false;
3017   }
3018
3019   this.bb.writeUint64(this.bb_pos + offset, value);
3020   return true;
3021 };
3022
3023 /**
3024  * @returns {number}
3025  */
3026 MyGame.Example.TypeAliases.prototype.f32 = function() {
3027   var offset = this.bb.__offset(this.bb_pos, 20);
3028   return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
3029 };
3030
3031 /**
3032  * @param {number} value
3033  * @returns {boolean}
3034  */
3035 MyGame.Example.TypeAliases.prototype.mutate_f32 = function(value) {
3036   var offset = this.bb.__offset(this.bb_pos, 20);
3037
3038   if (offset === 0) {
3039     return false;
3040   }
3041
3042   this.bb.writeFloat32(this.bb_pos + offset, value);
3043   return true;
3044 };
3045
3046 /**
3047  * @returns {number}
3048  */
3049 MyGame.Example.TypeAliases.prototype.f64 = function() {
3050   var offset = this.bb.__offset(this.bb_pos, 22);
3051   return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
3052 };
3053
3054 /**
3055  * @param {number} value
3056  * @returns {boolean}
3057  */
3058 MyGame.Example.TypeAliases.prototype.mutate_f64 = function(value) {
3059   var offset = this.bb.__offset(this.bb_pos, 22);
3060
3061   if (offset === 0) {
3062     return false;
3063   }
3064
3065   this.bb.writeFloat64(this.bb_pos + offset, value);
3066   return true;
3067 };
3068
3069 /**
3070  * @param {number} index
3071  * @returns {number}
3072  */
3073 MyGame.Example.TypeAliases.prototype.v8 = function(index) {
3074   var offset = this.bb.__offset(this.bb_pos, 24);
3075   return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
3076 };
3077
3078 /**
3079  * @returns {number}
3080  */
3081 MyGame.Example.TypeAliases.prototype.v8Length = function() {
3082   var offset = this.bb.__offset(this.bb_pos, 24);
3083   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
3084 };
3085
3086 /**
3087  * @returns {Int8Array}
3088  */
3089 MyGame.Example.TypeAliases.prototype.v8Array = function() {
3090   var offset = this.bb.__offset(this.bb_pos, 24);
3091   return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
3092 };
3093
3094 /**
3095  * @param {number} index
3096  * @returns {number}
3097  */
3098 MyGame.Example.TypeAliases.prototype.vf64 = function(index) {
3099   var offset = this.bb.__offset(this.bb_pos, 26);
3100   return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0;
3101 };
3102
3103 /**
3104  * @returns {number}
3105  */
3106 MyGame.Example.TypeAliases.prototype.vf64Length = function() {
3107   var offset = this.bb.__offset(this.bb_pos, 26);
3108   return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
3109 };
3110
3111 /**
3112  * @returns {Float64Array}
3113  */
3114 MyGame.Example.TypeAliases.prototype.vf64Array = function() {
3115   var offset = this.bb.__offset(this.bb_pos, 26);
3116   return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
3117 };
3118
3119 /**
3120  * @param {flatbuffers.Builder} builder
3121  */
3122 MyGame.Example.TypeAliases.startTypeAliases = function(builder) {
3123   builder.startObject(12);
3124 };
3125
3126 /**
3127  * @param {flatbuffers.Builder} builder
3128  * @param {number} i8
3129  */
3130 MyGame.Example.TypeAliases.addI8 = function(builder, i8) {
3131   builder.addFieldInt8(0, i8, 0);
3132 };
3133
3134 /**
3135  * @param {flatbuffers.Builder} builder
3136  * @param {number} u8
3137  */
3138 MyGame.Example.TypeAliases.addU8 = function(builder, u8) {
3139   builder.addFieldInt8(1, u8, 0);
3140 };
3141
3142 /**
3143  * @param {flatbuffers.Builder} builder
3144  * @param {number} i16
3145  */
3146 MyGame.Example.TypeAliases.addI16 = function(builder, i16) {
3147   builder.addFieldInt16(2, i16, 0);
3148 };
3149
3150 /**
3151  * @param {flatbuffers.Builder} builder
3152  * @param {number} u16
3153  */
3154 MyGame.Example.TypeAliases.addU16 = function(builder, u16) {
3155   builder.addFieldInt16(3, u16, 0);
3156 };
3157
3158 /**
3159  * @param {flatbuffers.Builder} builder
3160  * @param {number} i32
3161  */
3162 MyGame.Example.TypeAliases.addI32 = function(builder, i32) {
3163   builder.addFieldInt32(4, i32, 0);
3164 };
3165
3166 /**
3167  * @param {flatbuffers.Builder} builder
3168  * @param {number} u32
3169  */
3170 MyGame.Example.TypeAliases.addU32 = function(builder, u32) {
3171   builder.addFieldInt32(5, u32, 0);
3172 };
3173
3174 /**
3175  * @param {flatbuffers.Builder} builder
3176  * @param {flatbuffers.Long} i64
3177  */
3178 MyGame.Example.TypeAliases.addI64 = function(builder, i64) {
3179   builder.addFieldInt64(6, i64, builder.createLong(0, 0));
3180 };
3181
3182 /**
3183  * @param {flatbuffers.Builder} builder
3184  * @param {flatbuffers.Long} u64
3185  */
3186 MyGame.Example.TypeAliases.addU64 = function(builder, u64) {
3187   builder.addFieldInt64(7, u64, builder.createLong(0, 0));
3188 };
3189
3190 /**
3191  * @param {flatbuffers.Builder} builder
3192  * @param {number} f32
3193  */
3194 MyGame.Example.TypeAliases.addF32 = function(builder, f32) {
3195   builder.addFieldFloat32(8, f32, 0.0);
3196 };
3197
3198 /**
3199  * @param {flatbuffers.Builder} builder
3200  * @param {number} f64
3201  */
3202 MyGame.Example.TypeAliases.addF64 = function(builder, f64) {
3203   builder.addFieldFloat64(9, f64, 0.0);
3204 };
3205
3206 /**
3207  * @param {flatbuffers.Builder} builder
3208  * @param {flatbuffers.Offset} v8Offset
3209  */
3210 MyGame.Example.TypeAliases.addV8 = function(builder, v8Offset) {
3211   builder.addFieldOffset(10, v8Offset, 0);
3212 };
3213
3214 /**
3215  * @param {flatbuffers.Builder} builder
3216  * @param {Array.<number>} data
3217  * @returns {flatbuffers.Offset}
3218  */
3219 MyGame.Example.TypeAliases.createV8Vector = function(builder, data) {
3220   builder.startVector(1, data.length, 1);
3221   for (var i = data.length - 1; i >= 0; i--) {
3222     builder.addInt8(data[i]);
3223   }
3224   return builder.endVector();
3225 };
3226
3227 /**
3228  * @param {flatbuffers.Builder} builder
3229  * @param {number} numElems
3230  */
3231 MyGame.Example.TypeAliases.startV8Vector = function(builder, numElems) {
3232   builder.startVector(1, numElems, 1);
3233 };
3234
3235 /**
3236  * @param {flatbuffers.Builder} builder
3237  * @param {flatbuffers.Offset} vf64Offset
3238  */
3239 MyGame.Example.TypeAliases.addVf64 = function(builder, vf64Offset) {
3240   builder.addFieldOffset(11, vf64Offset, 0);
3241 };
3242
3243 /**
3244  * @param {flatbuffers.Builder} builder
3245  * @param {Array.<number>} data
3246  * @returns {flatbuffers.Offset}
3247  */
3248 MyGame.Example.TypeAliases.createVf64Vector = function(builder, data) {
3249   builder.startVector(8, data.length, 8);
3250   for (var i = data.length - 1; i >= 0; i--) {
3251     builder.addFloat64(data[i]);
3252   }
3253   return builder.endVector();
3254 };
3255
3256 /**
3257  * @param {flatbuffers.Builder} builder
3258  * @param {number} numElems
3259  */
3260 MyGame.Example.TypeAliases.startVf64Vector = function(builder, numElems) {
3261   builder.startVector(8, numElems, 8);
3262 };
3263
3264 /**
3265  * @param {flatbuffers.Builder} builder
3266  * @returns {flatbuffers.Offset}
3267  */
3268 MyGame.Example.TypeAliases.endTypeAliases = function(builder) {
3269   var offset = builder.endObject();
3270   return offset;
3271 };
3272
3273 /**
3274  * @param {flatbuffers.Builder} builder
3275  * @param {number} i8
3276  * @param {number} u8
3277  * @param {number} i16
3278  * @param {number} u16
3279  * @param {number} i32
3280  * @param {number} u32
3281  * @param {flatbuffers.Long} i64
3282  * @param {flatbuffers.Long} u64
3283  * @param {number} f32
3284  * @param {number} f64
3285  * @param {flatbuffers.Offset} v8Offset
3286  * @param {flatbuffers.Offset} vf64Offset
3287  * @returns {flatbuffers.Offset}
3288  */
3289 MyGame.Example.TypeAliases.createTypeAliases = function(builder, i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, v8Offset, vf64Offset) {
3290   MyGame.Example.TypeAliases.startTypeAliases(builder);
3291   MyGame.Example.TypeAliases.addI8(builder, i8);
3292   MyGame.Example.TypeAliases.addU8(builder, u8);
3293   MyGame.Example.TypeAliases.addI16(builder, i16);
3294   MyGame.Example.TypeAliases.addU16(builder, u16);
3295   MyGame.Example.TypeAliases.addI32(builder, i32);
3296   MyGame.Example.TypeAliases.addU32(builder, u32);
3297   MyGame.Example.TypeAliases.addI64(builder, i64);
3298   MyGame.Example.TypeAliases.addU64(builder, u64);
3299   MyGame.Example.TypeAliases.addF32(builder, f32);
3300   MyGame.Example.TypeAliases.addF64(builder, f64);
3301   MyGame.Example.TypeAliases.addV8(builder, v8Offset);
3302   MyGame.Example.TypeAliases.addVf64(builder, vf64Offset);
3303   return MyGame.Example.TypeAliases.endTypeAliases(builder);
3304 }
3305
3306 // Exports for Node.js and RequireJS
3307 this.MyGame = MyGame;