flatbuffers & transcoders

pkg/schema/fbs/battle.fbs

@@ -0,0 +1,52 @@
+// report reflects model/report/BattleReport data object
+namespace battle;
+
+struct UUID {
+  hi:uint64;
+  lo:uint64;
+}
+
+table RaceEntry {
+  key:int64;
+  value:UUID (required);
+}
+
+table TechEntry {
+  key:string;
+  value:float32;
+}
+
+table BattleReportGroup {
+  in_battle:bool;
+  number:uint64;
+  number_left:uint64;
+  load_quantity:float32;
+  tech:[TechEntry];
+  race:string;
+  class_name:string;
+  load_type:string;
+}
+
+table ShipEntry {
+  key:int64;
+  value:BattleReportGroup;
+}
+
+table BattleActionReport {
+  attacker:int64;
+  attacker_ship_class:int64;
+  defender:int64;
+  defender_ship_class:int64;
+  destroyed:bool;
+}
+
+table BattleReport {
+  id:UUID (required);
+  planet:uint64;
+  planet_name:string;
+  races:[RaceEntry];
+  ships:[ShipEntry];
+  protocol:[BattleActionReport];
+}
+
+root_type BattleReport;

pkg/schema/fbs/battle/BattleActionReport.go

@@ -0,0 +1,124 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package battle
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type BattleActionReport struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsBattleActionReport(buf []byte, offset flatbuffers.UOffsetT) *BattleActionReport {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &BattleActionReport{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishBattleActionReportBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsBattleActionReport(buf []byte, offset flatbuffers.UOffsetT) *BattleActionReport {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &BattleActionReport{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedBattleActionReportBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *BattleActionReport) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *BattleActionReport) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *BattleActionReport) Attacker() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *BattleActionReport) MutateAttacker(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *BattleActionReport) AttackerShipClass() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *BattleActionReport) MutateAttackerShipClass(n int64) bool {
+	return rcv._tab.MutateInt64Slot(6, n)
+}
+
+func (rcv *BattleActionReport) Defender() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *BattleActionReport) MutateDefender(n int64) bool {
+	return rcv._tab.MutateInt64Slot(8, n)
+}
+
+func (rcv *BattleActionReport) DefenderShipClass() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *BattleActionReport) MutateDefenderShipClass(n int64) bool {
+	return rcv._tab.MutateInt64Slot(10, n)
+}
+
+func (rcv *BattleActionReport) Destroyed() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *BattleActionReport) MutateDestroyed(n bool) bool {
+	return rcv._tab.MutateBoolSlot(12, n)
+}
+
+func BattleActionReportStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func BattleActionReportAddAttacker(builder *flatbuffers.Builder, attacker int64) {
+	builder.PrependInt64Slot(0, attacker, 0)
+}
+func BattleActionReportAddAttackerShipClass(builder *flatbuffers.Builder, attackerShipClass int64) {
+	builder.PrependInt64Slot(1, attackerShipClass, 0)
+}
+func BattleActionReportAddDefender(builder *flatbuffers.Builder, defender int64) {
+	builder.PrependInt64Slot(2, defender, 0)
+}
+func BattleActionReportAddDefenderShipClass(builder *flatbuffers.Builder, defenderShipClass int64) {
+	builder.PrependInt64Slot(3, defenderShipClass, 0)
+}
+func BattleActionReportAddDestroyed(builder *flatbuffers.Builder, destroyed bool) {
+	builder.PrependBoolSlot(4, destroyed, false)
+}
+func BattleActionReportEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/battle/BattleReport.go

@@ -0,0 +1,169 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package battle
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type BattleReport struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsBattleReport(buf []byte, offset flatbuffers.UOffsetT) *BattleReport {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &BattleReport{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishBattleReportBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsBattleReport(buf []byte, offset flatbuffers.UOffsetT) *BattleReport {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &BattleReport{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedBattleReportBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *BattleReport) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *BattleReport) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *BattleReport) Id(obj *UUID) *UUID {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := o + rcv._tab.Pos
+		if obj == nil {
+			obj = new(UUID)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *BattleReport) Planet() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *BattleReport) MutatePlanet(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(6, n)
+}
+
+func (rcv *BattleReport) PlanetName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *BattleReport) Races(obj *RaceEntry, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *BattleReport) RacesLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *BattleReport) Ships(obj *ShipEntry, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *BattleReport) ShipsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *BattleReport) Protocol(obj *BattleActionReport, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *BattleReport) ProtocolLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func BattleReportStart(builder *flatbuffers.Builder) {
+	builder.StartObject(6)
+}
+func BattleReportAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependStructSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func BattleReportAddPlanet(builder *flatbuffers.Builder, planet uint64) {
+	builder.PrependUint64Slot(1, planet, 0)
+}
+func BattleReportAddPlanetName(builder *flatbuffers.Builder, planetName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(planetName), 0)
+}
+func BattleReportAddRaces(builder *flatbuffers.Builder, races flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(races), 0)
+}
+func BattleReportStartRacesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func BattleReportAddShips(builder *flatbuffers.Builder, ships flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(ships), 0)
+}
+func BattleReportStartShipsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func BattleReportAddProtocol(builder *flatbuffers.Builder, protocol flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(protocol), 0)
+}
+func BattleReportStartProtocolVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func BattleReportEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/battle/BattleReportGroup.go

@@ -0,0 +1,168 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package battle
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type BattleReportGroup struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsBattleReportGroup(buf []byte, offset flatbuffers.UOffsetT) *BattleReportGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &BattleReportGroup{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishBattleReportGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsBattleReportGroup(buf []byte, offset flatbuffers.UOffsetT) *BattleReportGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &BattleReportGroup{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedBattleReportGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *BattleReportGroup) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *BattleReportGroup) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *BattleReportGroup) InBattle() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *BattleReportGroup) MutateInBattle(n bool) bool {
+	return rcv._tab.MutateBoolSlot(4, n)
+}
+
+func (rcv *BattleReportGroup) Number() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *BattleReportGroup) MutateNumber(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(6, n)
+}
+
+func (rcv *BattleReportGroup) NumberLeft() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *BattleReportGroup) MutateNumberLeft(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(8, n)
+}
+
+func (rcv *BattleReportGroup) LoadQuantity() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *BattleReportGroup) MutateLoadQuantity(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *BattleReportGroup) Tech(obj *TechEntry, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *BattleReportGroup) TechLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *BattleReportGroup) Race() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *BattleReportGroup) ClassName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *BattleReportGroup) LoadType() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func BattleReportGroupStart(builder *flatbuffers.Builder) {
+	builder.StartObject(8)
+}
+func BattleReportGroupAddInBattle(builder *flatbuffers.Builder, inBattle bool) {
+	builder.PrependBoolSlot(0, inBattle, false)
+}
+func BattleReportGroupAddNumber(builder *flatbuffers.Builder, number uint64) {
+	builder.PrependUint64Slot(1, number, 0)
+}
+func BattleReportGroupAddNumberLeft(builder *flatbuffers.Builder, numberLeft uint64) {
+	builder.PrependUint64Slot(2, numberLeft, 0)
+}
+func BattleReportGroupAddLoadQuantity(builder *flatbuffers.Builder, loadQuantity float32) {
+	builder.PrependFloat32Slot(3, loadQuantity, 0.0)
+}
+func BattleReportGroupAddTech(builder *flatbuffers.Builder, tech flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(tech), 0)
+}
+func BattleReportGroupStartTechVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func BattleReportGroupAddRace(builder *flatbuffers.Builder, race flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(race), 0)
+}
+func BattleReportGroupAddClassName(builder *flatbuffers.Builder, className flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(className), 0)
+}
+func BattleReportGroupAddLoadType(builder *flatbuffers.Builder, loadType flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(loadType), 0)
+}
+func BattleReportGroupEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/battle/RaceEntry.go

@@ -0,0 +1,80 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package battle
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type RaceEntry struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsRaceEntry(buf []byte, offset flatbuffers.UOffsetT) *RaceEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &RaceEntry{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishRaceEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsRaceEntry(buf []byte, offset flatbuffers.UOffsetT) *RaceEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &RaceEntry{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedRaceEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *RaceEntry) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *RaceEntry) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *RaceEntry) Key() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *RaceEntry) MutateKey(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *RaceEntry) Value(obj *UUID) *UUID {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		x := o + rcv._tab.Pos
+		if obj == nil {
+			obj = new(UUID)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func RaceEntryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func RaceEntryAddKey(builder *flatbuffers.Builder, key int64) {
+	builder.PrependInt64Slot(0, key, 0)
+}
+func RaceEntryAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) {
+	builder.PrependStructSlot(1, flatbuffers.UOffsetT(value), 0)
+}
+func RaceEntryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/battle/ShipEntry.go

@@ -0,0 +1,80 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package battle
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ShipEntry struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsShipEntry(buf []byte, offset flatbuffers.UOffsetT) *ShipEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ShipEntry{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishShipEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsShipEntry(buf []byte, offset flatbuffers.UOffsetT) *ShipEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ShipEntry{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedShipEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ShipEntry) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ShipEntry) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ShipEntry) Key() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ShipEntry) MutateKey(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *ShipEntry) Value(obj *BattleReportGroup) *BattleReportGroup {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(BattleReportGroup)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func ShipEntryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ShipEntryAddKey(builder *flatbuffers.Builder, key int64) {
+	builder.PrependInt64Slot(0, key, 0)
+}
+func ShipEntryAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(value), 0)
+}
+func ShipEntryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/battle/TechEntry.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package battle
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type TechEntry struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsTechEntry(buf []byte, offset flatbuffers.UOffsetT) *TechEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &TechEntry{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishTechEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsTechEntry(buf []byte, offset flatbuffers.UOffsetT) *TechEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &TechEntry{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedTechEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *TechEntry) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *TechEntry) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *TechEntry) Key() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *TechEntry) Value() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *TechEntry) MutateValue(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func TechEntryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func TechEntryAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(key), 0)
+}
+func TechEntryAddValue(builder *flatbuffers.Builder, value float32) {
+	builder.PrependFloat32Slot(1, value, 0.0)
+}
+func TechEntryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/battle/UUID.go

@@ -0,0 +1,41 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package battle
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type UUID struct {
+	_tab flatbuffers.Struct
+}
+
+func (rcv *UUID) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *UUID) Table() flatbuffers.Table {
+	return rcv._tab.Table
+}
+
+func (rcv *UUID) Hi() uint64 {
+	return rcv._tab.GetUint64(rcv._tab.Pos + flatbuffers.UOffsetT(0))
+}
+func (rcv *UUID) MutateHi(n uint64) bool {
+	return rcv._tab.MutateUint64(rcv._tab.Pos+flatbuffers.UOffsetT(0), n)
+}
+
+func (rcv *UUID) Lo() uint64 {
+	return rcv._tab.GetUint64(rcv._tab.Pos + flatbuffers.UOffsetT(8))
+}
+func (rcv *UUID) MutateLo(n uint64) bool {
+	return rcv._tab.MutateUint64(rcv._tab.Pos+flatbuffers.UOffsetT(8), n)
+}
+
+func CreateUUID(builder *flatbuffers.Builder, hi uint64, lo uint64) flatbuffers.UOffsetT {
+	builder.Prep(8, 16)
+	builder.PrependUint64(lo)
+	builder.PrependUint64(hi)
+	return builder.Offset()
+}

pkg/schema/fbs/order.fbs

@@ -1,3 +1,4 @@
+// order reflects model/order/Order data object
 namespace order;
 
 enum Relation : byte {

pkg/schema/fbs/order/CommandFleetMerge.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandFleetMerge struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandFleetMerge(buf []byte, offset flatbuffers.UOffsetT) *CommandFleetMerge {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandFleetMerge{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandFleetMergeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandFleetMerge(buf []byte, offset flatbuffers.UOffsetT) *CommandFleetMerge {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandFleetMerge{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandFleetMergeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandFleetMerge) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandFleetMerge) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandFleetMerge) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandFleetMerge) Target() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandFleetMergeStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandFleetMergeAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func CommandFleetMergeAddTarget(builder *flatbuffers.Builder, target flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(target), 0)
+}
+func CommandFleetMergeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandFleetSend.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandFleetSend struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandFleetSend(buf []byte, offset flatbuffers.UOffsetT) *CommandFleetSend {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandFleetSend{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandFleetSendBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandFleetSend(buf []byte, offset flatbuffers.UOffsetT) *CommandFleetSend {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandFleetSend{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandFleetSendBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandFleetSend) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandFleetSend) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandFleetSend) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandFleetSend) Destination() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandFleetSend) MutateDestination(n int64) bool {
+	return rcv._tab.MutateInt64Slot(6, n)
+}
+
+func CommandFleetSendStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandFleetSendAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func CommandFleetSendAddDestination(builder *flatbuffers.Builder, destination int64) {
+	builder.PrependInt64Slot(1, destination, 0)
+}
+func CommandFleetSendEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandItem.go

@@ -0,0 +1,121 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandItem struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandItem(buf []byte, offset flatbuffers.UOffsetT) *CommandItem {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandItem{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandItemBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandItem(buf []byte, offset flatbuffers.UOffsetT) *CommandItem {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandItem{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandItemBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandItem) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandItem) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandItem) CmdId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandItem) CmdApplied() *bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		v := rcv._tab.GetBool(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *CommandItem) MutateCmdApplied(n bool) bool {
+	return rcv._tab.MutateBoolSlot(6, n)
+}
+
+func (rcv *CommandItem) CmdErrorCode() *int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		v := rcv._tab.GetInt64(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *CommandItem) MutateCmdErrorCode(n int64) bool {
+	return rcv._tab.MutateInt64Slot(8, n)
+}
+
+func (rcv *CommandItem) PayloadType() CommandPayload {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return CommandPayload(rcv._tab.GetByte(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *CommandItem) MutatePayloadType(n CommandPayload) bool {
+	return rcv._tab.MutateByteSlot(10, byte(n))
+}
+
+func (rcv *CommandItem) Payload(obj *flatbuffers.Table) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		rcv._tab.Union(obj, o)
+		return true
+	}
+	return false
+}
+
+func CommandItemStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func CommandItemAddCmdId(builder *flatbuffers.Builder, cmdId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(cmdId), 0)
+}
+func CommandItemAddCmdApplied(builder *flatbuffers.Builder, cmdApplied bool) {
+	builder.PrependBool(cmdApplied)
+	builder.Slot(1)
+}
+func CommandItemAddCmdErrorCode(builder *flatbuffers.Builder, cmdErrorCode int64) {
+	builder.PrependInt64(cmdErrorCode)
+	builder.Slot(2)
+}
+func CommandItemAddPayloadType(builder *flatbuffers.Builder, payloadType CommandPayload) {
+	builder.PrependByteSlot(3, byte(payloadType), 0)
+}
+func CommandItemAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(payload), 0)
+}
+func CommandItemEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandPayload.go

@@ -0,0 +1,95 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import "strconv"
+
+type CommandPayload byte
+
+const (
+	CommandPayloadNONE                      CommandPayload = 0
+	CommandPayloadCommandRaceQuit           CommandPayload = 1
+	CommandPayloadCommandRaceVote           CommandPayload = 2
+	CommandPayloadCommandRaceRelation       CommandPayload = 3
+	CommandPayloadCommandShipClassCreate    CommandPayload = 4
+	CommandPayloadCommandShipClassMerge     CommandPayload = 5
+	CommandPayloadCommandShipClassRemove    CommandPayload = 6
+	CommandPayloadCommandShipGroupBreak     CommandPayload = 7
+	CommandPayloadCommandShipGroupLoad      CommandPayload = 8
+	CommandPayloadCommandShipGroupUnload    CommandPayload = 9
+	CommandPayloadCommandShipGroupSend      CommandPayload = 10
+	CommandPayloadCommandShipGroupUpgrade   CommandPayload = 11
+	CommandPayloadCommandShipGroupMerge     CommandPayload = 12
+	CommandPayloadCommandShipGroupDismantle CommandPayload = 13
+	CommandPayloadCommandShipGroupTransfer  CommandPayload = 14
+	CommandPayloadCommandShipGroupJoinFleet CommandPayload = 15
+	CommandPayloadCommandFleetMerge         CommandPayload = 16
+	CommandPayloadCommandFleetSend          CommandPayload = 17
+	CommandPayloadCommandScienceCreate      CommandPayload = 18
+	CommandPayloadCommandScienceRemove      CommandPayload = 19
+	CommandPayloadCommandPlanetRename       CommandPayload = 20
+	CommandPayloadCommandPlanetProduce      CommandPayload = 21
+	CommandPayloadCommandPlanetRouteSet     CommandPayload = 22
+	CommandPayloadCommandPlanetRouteRemove  CommandPayload = 23
+)
+
+var EnumNamesCommandPayload = map[CommandPayload]string{
+	CommandPayloadNONE:                      "NONE",
+	CommandPayloadCommandRaceQuit:           "CommandRaceQuit",
+	CommandPayloadCommandRaceVote:           "CommandRaceVote",
+	CommandPayloadCommandRaceRelation:       "CommandRaceRelation",
+	CommandPayloadCommandShipClassCreate:    "CommandShipClassCreate",
+	CommandPayloadCommandShipClassMerge:     "CommandShipClassMerge",
+	CommandPayloadCommandShipClassRemove:    "CommandShipClassRemove",
+	CommandPayloadCommandShipGroupBreak:     "CommandShipGroupBreak",
+	CommandPayloadCommandShipGroupLoad:      "CommandShipGroupLoad",
+	CommandPayloadCommandShipGroupUnload:    "CommandShipGroupUnload",
+	CommandPayloadCommandShipGroupSend:      "CommandShipGroupSend",
+	CommandPayloadCommandShipGroupUpgrade:   "CommandShipGroupUpgrade",
+	CommandPayloadCommandShipGroupMerge:     "CommandShipGroupMerge",
+	CommandPayloadCommandShipGroupDismantle: "CommandShipGroupDismantle",
+	CommandPayloadCommandShipGroupTransfer:  "CommandShipGroupTransfer",
+	CommandPayloadCommandShipGroupJoinFleet: "CommandShipGroupJoinFleet",
+	CommandPayloadCommandFleetMerge:         "CommandFleetMerge",
+	CommandPayloadCommandFleetSend:          "CommandFleetSend",
+	CommandPayloadCommandScienceCreate:      "CommandScienceCreate",
+	CommandPayloadCommandScienceRemove:      "CommandScienceRemove",
+	CommandPayloadCommandPlanetRename:       "CommandPlanetRename",
+	CommandPayloadCommandPlanetProduce:      "CommandPlanetProduce",
+	CommandPayloadCommandPlanetRouteSet:     "CommandPlanetRouteSet",
+	CommandPayloadCommandPlanetRouteRemove:  "CommandPlanetRouteRemove",
+}
+
+var EnumValuesCommandPayload = map[string]CommandPayload{
+	"NONE":                      CommandPayloadNONE,
+	"CommandRaceQuit":           CommandPayloadCommandRaceQuit,
+	"CommandRaceVote":           CommandPayloadCommandRaceVote,
+	"CommandRaceRelation":       CommandPayloadCommandRaceRelation,
+	"CommandShipClassCreate":    CommandPayloadCommandShipClassCreate,
+	"CommandShipClassMerge":     CommandPayloadCommandShipClassMerge,
+	"CommandShipClassRemove":    CommandPayloadCommandShipClassRemove,
+	"CommandShipGroupBreak":     CommandPayloadCommandShipGroupBreak,
+	"CommandShipGroupLoad":      CommandPayloadCommandShipGroupLoad,
+	"CommandShipGroupUnload":    CommandPayloadCommandShipGroupUnload,
+	"CommandShipGroupSend":      CommandPayloadCommandShipGroupSend,
+	"CommandShipGroupUpgrade":   CommandPayloadCommandShipGroupUpgrade,
+	"CommandShipGroupMerge":     CommandPayloadCommandShipGroupMerge,
+	"CommandShipGroupDismantle": CommandPayloadCommandShipGroupDismantle,
+	"CommandShipGroupTransfer":  CommandPayloadCommandShipGroupTransfer,
+	"CommandShipGroupJoinFleet": CommandPayloadCommandShipGroupJoinFleet,
+	"CommandFleetMerge":         CommandPayloadCommandFleetMerge,
+	"CommandFleetSend":          CommandPayloadCommandFleetSend,
+	"CommandScienceCreate":      CommandPayloadCommandScienceCreate,
+	"CommandScienceRemove":      CommandPayloadCommandScienceRemove,
+	"CommandPlanetRename":       CommandPayloadCommandPlanetRename,
+	"CommandPlanetProduce":      CommandPayloadCommandPlanetProduce,
+	"CommandPlanetRouteSet":     CommandPayloadCommandPlanetRouteSet,
+	"CommandPlanetRouteRemove":  CommandPayloadCommandPlanetRouteRemove,
+}
+
+func (v CommandPayload) String() string {
+	if s, ok := EnumNamesCommandPayload[v]; ok {
+		return s
+	}
+	return "CommandPayload(" + strconv.FormatInt(int64(v), 10) + ")"
+}

pkg/schema/fbs/order/CommandPlanetProduce.go

@@ -0,0 +1,90 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandPlanetProduce struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandPlanetProduce(buf []byte, offset flatbuffers.UOffsetT) *CommandPlanetProduce {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandPlanetProduce{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandPlanetProduceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandPlanetProduce(buf []byte, offset flatbuffers.UOffsetT) *CommandPlanetProduce {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandPlanetProduce{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandPlanetProduceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandPlanetProduce) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandPlanetProduce) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandPlanetProduce) Number() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandPlanetProduce) MutateNumber(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *CommandPlanetProduce) Production() PlanetProduction {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return PlanetProduction(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *CommandPlanetProduce) MutateProduction(n PlanetProduction) bool {
+	return rcv._tab.MutateInt8Slot(6, int8(n))
+}
+
+func (rcv *CommandPlanetProduce) Subject() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandPlanetProduceStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func CommandPlanetProduceAddNumber(builder *flatbuffers.Builder, number int64) {
+	builder.PrependInt64Slot(0, number, 0)
+}
+func CommandPlanetProduceAddProduction(builder *flatbuffers.Builder, production PlanetProduction) {
+	builder.PrependInt8Slot(1, int8(production), 0)
+}
+func CommandPlanetProduceAddSubject(builder *flatbuffers.Builder, subject flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(subject), 0)
+}
+func CommandPlanetProduceEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandPlanetRename.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandPlanetRename struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandPlanetRename(buf []byte, offset flatbuffers.UOffsetT) *CommandPlanetRename {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandPlanetRename{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandPlanetRenameBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandPlanetRename(buf []byte, offset flatbuffers.UOffsetT) *CommandPlanetRename {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandPlanetRename{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandPlanetRenameBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandPlanetRename) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandPlanetRename) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandPlanetRename) Number() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandPlanetRename) MutateNumber(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *CommandPlanetRename) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandPlanetRenameStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandPlanetRenameAddNumber(builder *flatbuffers.Builder, number int64) {
+	builder.PrependInt64Slot(0, number, 0)
+}
+func CommandPlanetRenameAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(name), 0)
+}
+func CommandPlanetRenameEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandPlanetRouteRemove.go

@@ -0,0 +1,79 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandPlanetRouteRemove struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandPlanetRouteRemove(buf []byte, offset flatbuffers.UOffsetT) *CommandPlanetRouteRemove {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandPlanetRouteRemove{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandPlanetRouteRemoveBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandPlanetRouteRemove(buf []byte, offset flatbuffers.UOffsetT) *CommandPlanetRouteRemove {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandPlanetRouteRemove{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandPlanetRouteRemoveBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandPlanetRouteRemove) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandPlanetRouteRemove) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandPlanetRouteRemove) Origin() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandPlanetRouteRemove) MutateOrigin(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *CommandPlanetRouteRemove) LoadType() PlanetRouteLoadType {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return PlanetRouteLoadType(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *CommandPlanetRouteRemove) MutateLoadType(n PlanetRouteLoadType) bool {
+	return rcv._tab.MutateInt8Slot(6, int8(n))
+}
+
+func CommandPlanetRouteRemoveStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandPlanetRouteRemoveAddOrigin(builder *flatbuffers.Builder, origin int64) {
+	builder.PrependInt64Slot(0, origin, 0)
+}
+func CommandPlanetRouteRemoveAddLoadType(builder *flatbuffers.Builder, loadType PlanetRouteLoadType) {
+	builder.PrependInt8Slot(1, int8(loadType), 0)
+}
+func CommandPlanetRouteRemoveEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandPlanetRouteSet.go

@@ -0,0 +1,94 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandPlanetRouteSet struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandPlanetRouteSet(buf []byte, offset flatbuffers.UOffsetT) *CommandPlanetRouteSet {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandPlanetRouteSet{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandPlanetRouteSetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandPlanetRouteSet(buf []byte, offset flatbuffers.UOffsetT) *CommandPlanetRouteSet {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandPlanetRouteSet{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandPlanetRouteSetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandPlanetRouteSet) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandPlanetRouteSet) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandPlanetRouteSet) Origin() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandPlanetRouteSet) MutateOrigin(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *CommandPlanetRouteSet) Destination() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandPlanetRouteSet) MutateDestination(n int64) bool {
+	return rcv._tab.MutateInt64Slot(6, n)
+}
+
+func (rcv *CommandPlanetRouteSet) LoadType() PlanetRouteLoadType {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return PlanetRouteLoadType(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *CommandPlanetRouteSet) MutateLoadType(n PlanetRouteLoadType) bool {
+	return rcv._tab.MutateInt8Slot(8, int8(n))
+}
+
+func CommandPlanetRouteSetStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func CommandPlanetRouteSetAddOrigin(builder *flatbuffers.Builder, origin int64) {
+	builder.PrependInt64Slot(0, origin, 0)
+}
+func CommandPlanetRouteSetAddDestination(builder *flatbuffers.Builder, destination int64) {
+	builder.PrependInt64Slot(1, destination, 0)
+}
+func CommandPlanetRouteSetAddLoadType(builder *flatbuffers.Builder, loadType PlanetRouteLoadType) {
+	builder.PrependInt8Slot(2, int8(loadType), 0)
+}
+func CommandPlanetRouteSetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandRaceQuit.go

@@ -0,0 +1,49 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandRaceQuit struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandRaceQuit(buf []byte, offset flatbuffers.UOffsetT) *CommandRaceQuit {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandRaceQuit{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandRaceQuitBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandRaceQuit(buf []byte, offset flatbuffers.UOffsetT) *CommandRaceQuit {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandRaceQuit{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandRaceQuitBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandRaceQuit) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandRaceQuit) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func CommandRaceQuitStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func CommandRaceQuitEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandRaceRelation.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandRaceRelation struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandRaceRelation(buf []byte, offset flatbuffers.UOffsetT) *CommandRaceRelation {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandRaceRelation{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandRaceRelationBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandRaceRelation(buf []byte, offset flatbuffers.UOffsetT) *CommandRaceRelation {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandRaceRelation{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandRaceRelationBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandRaceRelation) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandRaceRelation) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandRaceRelation) Acceptor() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandRaceRelation) Relation() Relation {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return Relation(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *CommandRaceRelation) MutateRelation(n Relation) bool {
+	return rcv._tab.MutateInt8Slot(6, int8(n))
+}
+
+func CommandRaceRelationStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandRaceRelationAddAcceptor(builder *flatbuffers.Builder, acceptor flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(acceptor), 0)
+}
+func CommandRaceRelationAddRelation(builder *flatbuffers.Builder, relation Relation) {
+	builder.PrependInt8Slot(1, int8(relation), 0)
+}
+func CommandRaceRelationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandRaceVote.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandRaceVote struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandRaceVote(buf []byte, offset flatbuffers.UOffsetT) *CommandRaceVote {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandRaceVote{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandRaceVoteBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandRaceVote(buf []byte, offset flatbuffers.UOffsetT) *CommandRaceVote {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandRaceVote{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandRaceVoteBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandRaceVote) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandRaceVote) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandRaceVote) Acceptor() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandRaceVoteStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func CommandRaceVoteAddAcceptor(builder *flatbuffers.Builder, acceptor flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(acceptor), 0)
+}
+func CommandRaceVoteEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandScienceCreate.go

@@ -0,0 +1,120 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandScienceCreate struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandScienceCreate(buf []byte, offset flatbuffers.UOffsetT) *CommandScienceCreate {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandScienceCreate{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandScienceCreateBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandScienceCreate(buf []byte, offset flatbuffers.UOffsetT) *CommandScienceCreate {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandScienceCreate{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandScienceCreateBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandScienceCreate) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandScienceCreate) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandScienceCreate) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandScienceCreate) Drive() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandScienceCreate) MutateDrive(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(6, n)
+}
+
+func (rcv *CommandScienceCreate) Weapons() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandScienceCreate) MutateWeapons(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(8, n)
+}
+
+func (rcv *CommandScienceCreate) Shields() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandScienceCreate) MutateShields(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(10, n)
+}
+
+func (rcv *CommandScienceCreate) Cargo() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandScienceCreate) MutateCargo(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(12, n)
+}
+
+func CommandScienceCreateStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func CommandScienceCreateAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func CommandScienceCreateAddDrive(builder *flatbuffers.Builder, drive float64) {
+	builder.PrependFloat64Slot(1, drive, 0.0)
+}
+func CommandScienceCreateAddWeapons(builder *flatbuffers.Builder, weapons float64) {
+	builder.PrependFloat64Slot(2, weapons, 0.0)
+}
+func CommandScienceCreateAddShields(builder *flatbuffers.Builder, shields float64) {
+	builder.PrependFloat64Slot(3, shields, 0.0)
+}
+func CommandScienceCreateAddCargo(builder *flatbuffers.Builder, cargo float64) {
+	builder.PrependFloat64Slot(4, cargo, 0.0)
+}
+func CommandScienceCreateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandScienceRemove.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandScienceRemove struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandScienceRemove(buf []byte, offset flatbuffers.UOffsetT) *CommandScienceRemove {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandScienceRemove{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandScienceRemoveBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandScienceRemove(buf []byte, offset flatbuffers.UOffsetT) *CommandScienceRemove {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandScienceRemove{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandScienceRemoveBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandScienceRemove) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandScienceRemove) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandScienceRemove) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandScienceRemoveStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func CommandScienceRemoveAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func CommandScienceRemoveEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipClassCreate.go

@@ -0,0 +1,135 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipClassCreate struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipClassCreate(buf []byte, offset flatbuffers.UOffsetT) *CommandShipClassCreate {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipClassCreate{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipClassCreateBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipClassCreate(buf []byte, offset flatbuffers.UOffsetT) *CommandShipClassCreate {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipClassCreate{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipClassCreateBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipClassCreate) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipClassCreate) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipClassCreate) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipClassCreate) Drive() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandShipClassCreate) MutateDrive(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(6, n)
+}
+
+func (rcv *CommandShipClassCreate) Armament() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandShipClassCreate) MutateArmament(n int64) bool {
+	return rcv._tab.MutateInt64Slot(8, n)
+}
+
+func (rcv *CommandShipClassCreate) Weapons() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandShipClassCreate) MutateWeapons(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(10, n)
+}
+
+func (rcv *CommandShipClassCreate) Shields() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandShipClassCreate) MutateShields(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(12, n)
+}
+
+func (rcv *CommandShipClassCreate) Cargo() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandShipClassCreate) MutateCargo(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(14, n)
+}
+
+func CommandShipClassCreateStart(builder *flatbuffers.Builder) {
+	builder.StartObject(6)
+}
+func CommandShipClassCreateAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func CommandShipClassCreateAddDrive(builder *flatbuffers.Builder, drive float64) {
+	builder.PrependFloat64Slot(1, drive, 0.0)
+}
+func CommandShipClassCreateAddArmament(builder *flatbuffers.Builder, armament int64) {
+	builder.PrependInt64Slot(2, armament, 0)
+}
+func CommandShipClassCreateAddWeapons(builder *flatbuffers.Builder, weapons float64) {
+	builder.PrependFloat64Slot(3, weapons, 0.0)
+}
+func CommandShipClassCreateAddShields(builder *flatbuffers.Builder, shields float64) {
+	builder.PrependFloat64Slot(4, shields, 0.0)
+}
+func CommandShipClassCreateAddCargo(builder *flatbuffers.Builder, cargo float64) {
+	builder.PrependFloat64Slot(5, cargo, 0.0)
+}
+func CommandShipClassCreateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipClassMerge.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipClassMerge struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipClassMerge(buf []byte, offset flatbuffers.UOffsetT) *CommandShipClassMerge {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipClassMerge{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipClassMergeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipClassMerge(buf []byte, offset flatbuffers.UOffsetT) *CommandShipClassMerge {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipClassMerge{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipClassMergeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipClassMerge) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipClassMerge) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipClassMerge) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipClassMerge) Target() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandShipClassMergeStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandShipClassMergeAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func CommandShipClassMergeAddTarget(builder *flatbuffers.Builder, target flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(target), 0)
+}
+func CommandShipClassMergeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipClassRemove.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipClassRemove struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipClassRemove(buf []byte, offset flatbuffers.UOffsetT) *CommandShipClassRemove {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipClassRemove{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipClassRemoveBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipClassRemove(buf []byte, offset flatbuffers.UOffsetT) *CommandShipClassRemove {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipClassRemove{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipClassRemoveBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipClassRemove) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipClassRemove) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipClassRemove) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandShipClassRemoveStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func CommandShipClassRemoveAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func CommandShipClassRemoveEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupBreak.go

@@ -0,0 +1,86 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupBreak struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupBreak(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupBreak {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupBreak{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupBreakBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupBreak(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupBreak {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupBreak{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupBreakBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupBreak) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupBreak) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipGroupBreak) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipGroupBreak) NewId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipGroupBreak) Quantity() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandShipGroupBreak) MutateQuantity(n int64) bool {
+	return rcv._tab.MutateInt64Slot(8, n)
+}
+
+func CommandShipGroupBreakStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func CommandShipGroupBreakAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func CommandShipGroupBreakAddNewId(builder *flatbuffers.Builder, newId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(newId), 0)
+}
+func CommandShipGroupBreakAddQuantity(builder *flatbuffers.Builder, quantity int64) {
+	builder.PrependInt64Slot(2, quantity, 0)
+}
+func CommandShipGroupBreakEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupDismantle.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupDismantle struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupDismantle(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupDismantle {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupDismantle{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupDismantleBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupDismantle(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupDismantle {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupDismantle{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupDismantleBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupDismantle) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupDismantle) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipGroupDismantle) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandShipGroupDismantleStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func CommandShipGroupDismantleAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func CommandShipGroupDismantleEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupJoinFleet.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupJoinFleet struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupJoinFleet(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupJoinFleet {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupJoinFleet{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupJoinFleetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupJoinFleet(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupJoinFleet {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupJoinFleet{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupJoinFleetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupJoinFleet) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupJoinFleet) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipGroupJoinFleet) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipGroupJoinFleet) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandShipGroupJoinFleetStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandShipGroupJoinFleetAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func CommandShipGroupJoinFleetAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(name), 0)
+}
+func CommandShipGroupJoinFleetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupLoad.go

@@ -0,0 +1,90 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupLoad struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupLoad(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupLoad {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupLoad{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupLoadBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupLoad(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupLoad {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupLoad{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupLoadBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupLoad) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupLoad) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipGroupLoad) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipGroupLoad) Cargo() ShipGroupCargo {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return ShipGroupCargo(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *CommandShipGroupLoad) MutateCargo(n ShipGroupCargo) bool {
+	return rcv._tab.MutateInt8Slot(6, int8(n))
+}
+
+func (rcv *CommandShipGroupLoad) Quantity() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandShipGroupLoad) MutateQuantity(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(8, n)
+}
+
+func CommandShipGroupLoadStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func CommandShipGroupLoadAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func CommandShipGroupLoadAddCargo(builder *flatbuffers.Builder, cargo ShipGroupCargo) {
+	builder.PrependInt8Slot(1, int8(cargo), 0)
+}
+func CommandShipGroupLoadAddQuantity(builder *flatbuffers.Builder, quantity float64) {
+	builder.PrependFloat64Slot(2, quantity, 0.0)
+}
+func CommandShipGroupLoadEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupMerge.go

@@ -0,0 +1,49 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupMerge struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupMerge(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupMerge {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupMerge{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupMergeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupMerge(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupMerge {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupMerge{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupMergeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupMerge) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupMerge) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func CommandShipGroupMergeStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func CommandShipGroupMergeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupSend.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupSend struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupSend(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupSend {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupSend{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupSendBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupSend(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupSend {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupSend{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupSendBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupSend) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupSend) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipGroupSend) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipGroupSend) Destination() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *CommandShipGroupSend) MutateDestination(n int64) bool {
+	return rcv._tab.MutateInt64Slot(6, n)
+}
+
+func CommandShipGroupSendStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandShipGroupSendAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func CommandShipGroupSendAddDestination(builder *flatbuffers.Builder, destination int64) {
+	builder.PrependInt64Slot(1, destination, 0)
+}
+func CommandShipGroupSendEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupTransfer.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupTransfer struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupTransfer(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupTransfer {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupTransfer{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupTransferBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupTransfer(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupTransfer {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupTransfer{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupTransferBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupTransfer) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupTransfer) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipGroupTransfer) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipGroupTransfer) Acceptor() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func CommandShipGroupTransferStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandShipGroupTransferAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func CommandShipGroupTransferAddAcceptor(builder *flatbuffers.Builder, acceptor flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(acceptor), 0)
+}
+func CommandShipGroupTransferEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupUnload.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupUnload struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupUnload(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupUnload {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupUnload{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupUnloadBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupUnload(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupUnload {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupUnload{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupUnloadBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupUnload) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupUnload) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipGroupUnload) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipGroupUnload) Quantity() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandShipGroupUnload) MutateQuantity(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(6, n)
+}
+
+func CommandShipGroupUnloadStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func CommandShipGroupUnloadAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func CommandShipGroupUnloadAddQuantity(builder *flatbuffers.Builder, quantity float64) {
+	builder.PrependFloat64Slot(1, quantity, 0.0)
+}
+func CommandShipGroupUnloadEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/CommandShipGroupUpgrade.go

@@ -0,0 +1,90 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type CommandShipGroupUpgrade struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsCommandShipGroupUpgrade(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupUpgrade {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &CommandShipGroupUpgrade{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishCommandShipGroupUpgradeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsCommandShipGroupUpgrade(buf []byte, offset flatbuffers.UOffsetT) *CommandShipGroupUpgrade {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &CommandShipGroupUpgrade{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedCommandShipGroupUpgradeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *CommandShipGroupUpgrade) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *CommandShipGroupUpgrade) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *CommandShipGroupUpgrade) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *CommandShipGroupUpgrade) Tech() ShipGroupUpgradeTech {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return ShipGroupUpgradeTech(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *CommandShipGroupUpgrade) MutateTech(n ShipGroupUpgradeTech) bool {
+	return rcv._tab.MutateInt8Slot(6, int8(n))
+}
+
+func (rcv *CommandShipGroupUpgrade) Level() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *CommandShipGroupUpgrade) MutateLevel(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(8, n)
+}
+
+func CommandShipGroupUpgradeStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func CommandShipGroupUpgradeAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
+}
+func CommandShipGroupUpgradeAddTech(builder *flatbuffers.Builder, tech ShipGroupUpgradeTech) {
+	builder.PrependInt8Slot(1, int8(tech), 0)
+}
+func CommandShipGroupUpgradeAddLevel(builder *flatbuffers.Builder, level float64) {
+	builder.PrependFloat64Slot(2, level, 0.0)
+}
+func CommandShipGroupUpgradeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/Order.go

@@ -0,0 +1,90 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Order struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOrder(buf []byte, offset flatbuffers.UOffsetT) *Order {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Order{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOrderBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOrder(buf []byte, offset flatbuffers.UOffsetT) *Order {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Order{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOrderBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Order) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Order) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Order) UpdatedAt() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Order) MutateUpdatedAt(n int64) bool {
+	return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *Order) Commands(obj *CommandItem, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Order) CommandsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func OrderStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func OrderAddUpdatedAt(builder *flatbuffers.Builder, updatedAt int64) {
+	builder.PrependInt64Slot(0, updatedAt, 0)
+}
+func OrderAddCommands(builder *flatbuffers.Builder, commands flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(commands), 0)
+}
+func OrderStartCommandsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func OrderEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/order/PlanetProduction.go

@@ -0,0 +1,50 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import "strconv"
+
+type PlanetProduction int8
+
+const (
+	PlanetProductionUNKNOWN PlanetProduction = 0
+	PlanetProductionMAT     PlanetProduction = 1
+	PlanetProductionCAP     PlanetProduction = 2
+	PlanetProductionDRIVE   PlanetProduction = 3
+	PlanetProductionWEAPONS PlanetProduction = 4
+	PlanetProductionSHIELDS PlanetProduction = 5
+	PlanetProductionCARGO   PlanetProduction = 6
+	PlanetProductionSCIENCE PlanetProduction = 7
+	PlanetProductionSHIP    PlanetProduction = 8
+)
+
+var EnumNamesPlanetProduction = map[PlanetProduction]string{
+	PlanetProductionUNKNOWN: "UNKNOWN",
+	PlanetProductionMAT:     "MAT",
+	PlanetProductionCAP:     "CAP",
+	PlanetProductionDRIVE:   "DRIVE",
+	PlanetProductionWEAPONS: "WEAPONS",
+	PlanetProductionSHIELDS: "SHIELDS",
+	PlanetProductionCARGO:   "CARGO",
+	PlanetProductionSCIENCE: "SCIENCE",
+	PlanetProductionSHIP:    "SHIP",
+}
+
+var EnumValuesPlanetProduction = map[string]PlanetProduction{
+	"UNKNOWN": PlanetProductionUNKNOWN,
+	"MAT":     PlanetProductionMAT,
+	"CAP":     PlanetProductionCAP,
+	"DRIVE":   PlanetProductionDRIVE,
+	"WEAPONS": PlanetProductionWEAPONS,
+	"SHIELDS": PlanetProductionSHIELDS,
+	"CARGO":   PlanetProductionCARGO,
+	"SCIENCE": PlanetProductionSCIENCE,
+	"SHIP":    PlanetProductionSHIP,
+}
+
+func (v PlanetProduction) String() string {
+	if s, ok := EnumNamesPlanetProduction[v]; ok {
+		return s
+	}
+	return "PlanetProduction(" + strconv.FormatInt(int64(v), 10) + ")"
+}

pkg/schema/fbs/order/PlanetRouteLoadType.go

@@ -0,0 +1,38 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import "strconv"
+
+type PlanetRouteLoadType int8
+
+const (
+	PlanetRouteLoadTypeUNKNOWN PlanetRouteLoadType = 0
+	PlanetRouteLoadTypeMAT     PlanetRouteLoadType = 1
+	PlanetRouteLoadTypeCAP     PlanetRouteLoadType = 2
+	PlanetRouteLoadTypeCOL     PlanetRouteLoadType = 3
+	PlanetRouteLoadTypeEMP     PlanetRouteLoadType = 4
+)
+
+var EnumNamesPlanetRouteLoadType = map[PlanetRouteLoadType]string{
+	PlanetRouteLoadTypeUNKNOWN: "UNKNOWN",
+	PlanetRouteLoadTypeMAT:     "MAT",
+	PlanetRouteLoadTypeCAP:     "CAP",
+	PlanetRouteLoadTypeCOL:     "COL",
+	PlanetRouteLoadTypeEMP:     "EMP",
+}
+
+var EnumValuesPlanetRouteLoadType = map[string]PlanetRouteLoadType{
+	"UNKNOWN": PlanetRouteLoadTypeUNKNOWN,
+	"MAT":     PlanetRouteLoadTypeMAT,
+	"CAP":     PlanetRouteLoadTypeCAP,
+	"COL":     PlanetRouteLoadTypeCOL,
+	"EMP":     PlanetRouteLoadTypeEMP,
+}
+
+func (v PlanetRouteLoadType) String() string {
+	if s, ok := EnumNamesPlanetRouteLoadType[v]; ok {
+		return s
+	}
+	return "PlanetRouteLoadType(" + strconv.FormatInt(int64(v), 10) + ")"
+}

pkg/schema/fbs/order/Relation.go

@@ -0,0 +1,32 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import "strconv"
+
+type Relation int8
+
+const (
+	RelationUNKNOWN Relation = 0
+	RelationWAR     Relation = 1
+	RelationPEACE   Relation = 2
+)
+
+var EnumNamesRelation = map[Relation]string{
+	RelationUNKNOWN: "UNKNOWN",
+	RelationWAR:     "WAR",
+	RelationPEACE:   "PEACE",
+}
+
+var EnumValuesRelation = map[string]Relation{
+	"UNKNOWN": RelationUNKNOWN,
+	"WAR":     RelationWAR,
+	"PEACE":   RelationPEACE,
+}
+
+func (v Relation) String() string {
+	if s, ok := EnumNamesRelation[v]; ok {
+		return s
+	}
+	return "Relation(" + strconv.FormatInt(int64(v), 10) + ")"
+}

pkg/schema/fbs/order/ShipGroupCargo.go

@@ -0,0 +1,35 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import "strconv"
+
+type ShipGroupCargo int8
+
+const (
+	ShipGroupCargoUNKNOWN ShipGroupCargo = 0
+	ShipGroupCargoCOL     ShipGroupCargo = 1
+	ShipGroupCargoMAT     ShipGroupCargo = 2
+	ShipGroupCargoCAP     ShipGroupCargo = 3
+)
+
+var EnumNamesShipGroupCargo = map[ShipGroupCargo]string{
+	ShipGroupCargoUNKNOWN: "UNKNOWN",
+	ShipGroupCargoCOL:     "COL",
+	ShipGroupCargoMAT:     "MAT",
+	ShipGroupCargoCAP:     "CAP",
+}
+
+var EnumValuesShipGroupCargo = map[string]ShipGroupCargo{
+	"UNKNOWN": ShipGroupCargoUNKNOWN,
+	"COL":     ShipGroupCargoCOL,
+	"MAT":     ShipGroupCargoMAT,
+	"CAP":     ShipGroupCargoCAP,
+}
+
+func (v ShipGroupCargo) String() string {
+	if s, ok := EnumNamesShipGroupCargo[v]; ok {
+		return s
+	}
+	return "ShipGroupCargo(" + strconv.FormatInt(int64(v), 10) + ")"
+}

pkg/schema/fbs/order/ShipGroupUpgradeTech.go

@@ -0,0 +1,41 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package order
+
+import "strconv"
+
+type ShipGroupUpgradeTech int8
+
+const (
+	ShipGroupUpgradeTechUNKNOWN ShipGroupUpgradeTech = 0
+	ShipGroupUpgradeTechALL     ShipGroupUpgradeTech = 1
+	ShipGroupUpgradeTechDRIVE   ShipGroupUpgradeTech = 2
+	ShipGroupUpgradeTechWEAPONS ShipGroupUpgradeTech = 3
+	ShipGroupUpgradeTechSHIELDS ShipGroupUpgradeTech = 4
+	ShipGroupUpgradeTechCARGO   ShipGroupUpgradeTech = 5
+)
+
+var EnumNamesShipGroupUpgradeTech = map[ShipGroupUpgradeTech]string{
+	ShipGroupUpgradeTechUNKNOWN: "UNKNOWN",
+	ShipGroupUpgradeTechALL:     "ALL",
+	ShipGroupUpgradeTechDRIVE:   "DRIVE",
+	ShipGroupUpgradeTechWEAPONS: "WEAPONS",
+	ShipGroupUpgradeTechSHIELDS: "SHIELDS",
+	ShipGroupUpgradeTechCARGO:   "CARGO",
+}
+
+var EnumValuesShipGroupUpgradeTech = map[string]ShipGroupUpgradeTech{
+	"UNKNOWN": ShipGroupUpgradeTechUNKNOWN,
+	"ALL":     ShipGroupUpgradeTechALL,
+	"DRIVE":   ShipGroupUpgradeTechDRIVE,
+	"WEAPONS": ShipGroupUpgradeTechWEAPONS,
+	"SHIELDS": ShipGroupUpgradeTechSHIELDS,
+	"CARGO":   ShipGroupUpgradeTechCARGO,
+}
+
+func (v ShipGroupUpgradeTech) String() string {
+	if s, ok := EnumNamesShipGroupUpgradeTech[v]; ok {
+		return s
+	}
+	return "ShipGroupUpgradeTech(" + strconv.FormatInt(int64(v), 10) + ")"
+}

pkg/schema/fbs/report.fbs

@@ -0,0 +1,231 @@
+// report reflects model/report/Report data object
+namespace report;
+
+struct UUID {
+  hi:uint64;
+  lo:uint64;
+}
+
+table RouteEntry {
+  key:uint64;
+  value:string;
+}
+
+table TechEntry {
+  key:string;
+  value:float32;
+}
+
+table Route {
+  planet:uint64;
+  route:[RouteEntry];
+}
+
+table Player {
+  name:string;
+  drive:float32;
+  weapons:float32;
+  shields:float32;
+  cargo:float32;
+  population:float32;
+  industry:float32;
+  planets:uint16;
+  relation:string;
+  votes:float32;
+  extinct:bool;
+}
+
+table Science {
+  name:string;
+  drive:float32;
+  weapons:float32;
+  shields:float32;
+  cargo:float32;
+}
+
+table OtherScience {
+  race:string;
+  name:string;
+  drive:float32;
+  weapons:float32;
+  shields:float32;
+  cargo:float32;
+}
+
+table ShipClass {
+  name:string;
+  drive:float32;
+  armament:uint64;
+  weapons:float32;
+  shields:float32;
+  cargo:float32;
+  mass:float32;
+}
+
+table OthersShipClass {
+  race:string;
+  name:string;
+  drive:float32;
+  armament:uint64;
+  weapons:float32;
+  shields:float32;
+  cargo:float32;
+  mass:float32;
+}
+
+table ShipProduction {
+  planet:uint64;
+  class:string;
+  cost:float32;
+  prod_used:float32;
+  percent:float32;
+  free:float32;
+}
+
+table IncomingGroup {
+  origin:uint64;
+  destination:uint64;
+  distance:float32;
+  speed:float32;
+  mass:float32;
+}
+
+table Bombing {
+  number:uint64;
+  planet:string;
+  owner:string;
+  attacker:string;
+  production:string;
+  industry:float32;
+  population:float32;
+  colonists:float32;
+  capital:float32;
+  material:float32;
+  attack_power:float32;
+  wiped:bool;
+}
+
+table UnidentifiedPlanet {
+  x:float32;
+  y:float32;
+  number:uint64;
+}
+
+table UninhabitedPlanet {
+  x:float32;
+  y:float32;
+  number:uint64;
+  size:float32;
+  name:string;
+  resources:float32;
+  capital:float32;
+  material:float32;
+}
+
+table LocalPlanet {
+  x:float32;
+  y:float32;
+  number:uint64;
+  size:float32;
+  name:string;
+  resources:float32;
+  capital:float32;
+  material:float32;
+  industry:float32;
+  population:float32;
+  colonists:float32;
+  production:string;
+  free_industry:float32;
+}
+
+table OtherPlanet {
+  owner:string;
+  x:float32;
+  y:float32;
+  number:uint64;
+  size:float32;
+  name:string;
+  resources:float32;
+  capital:float32;
+  material:float32;
+  industry:float32;
+  population:float32;
+  colonists:float32;
+  production:string;
+  free_industry:float32;
+}
+
+table UnidentifiedGroup {
+  x:float32;
+  y:float32;
+}
+
+table OtherGroup {
+  number:uint64;
+  class:string;
+  tech:[TechEntry];
+  cargo:string;
+  load:float32;
+  destination:uint64;
+  origin:uint64 = null;
+  range:float32 = null;
+  speed:float32;
+  mass:float32;
+}
+
+table LocalGroup {
+  number:uint64;
+  class:string;
+  tech:[TechEntry];
+  cargo:string;
+  load:float32;
+  destination:uint64;
+  origin:uint64 = null;
+  range:float32 = null;
+  speed:float32;
+  mass:float32;
+  id:UUID (required);
+  state:string;
+  fleet:string;
+}
+
+table LocalFleet {
+  name:string;
+  groups:uint64;
+  destination:uint64;
+  origin:uint64 = null;
+  range:float32 = null;
+  speed:float32;
+  state:string;
+}
+
+table Report {
+  version:uint64;
+  turn:uint64;
+  width:uint32;
+  height:uint32;
+  planet_count:uint32;
+  race:string;
+  votes:float32;
+  vote_for:string;
+  player:[Player];
+  local_science:[Science];
+  other_science:[OtherScience];
+  local_ship_class:[ShipClass];
+  other_ship_class:[OthersShipClass];
+  battle:[UUID];
+  bombing:[Bombing];
+  incoming_group:[IncomingGroup];
+  local_planet:[LocalPlanet];
+  ship_production:[ShipProduction];
+  route:[Route];
+  other_planet:[OtherPlanet];
+  uninhabited_planet:[UninhabitedPlanet];
+  unidentified_planet:[UnidentifiedPlanet];
+  local_fleet:[LocalFleet];
+  local_group:[LocalGroup];
+  other_group:[OtherGroup];
+  unidentified_group:[UnidentifiedGroup];
+}
+
+root_type Report;

pkg/schema/fbs/report/Bombing.go

@@ -0,0 +1,213 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Bombing struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsBombing(buf []byte, offset flatbuffers.UOffsetT) *Bombing {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Bombing{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishBombingBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsBombing(buf []byte, offset flatbuffers.UOffsetT) *Bombing {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Bombing{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedBombingBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Bombing) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Bombing) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Bombing) Number() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Bombing) MutateNumber(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *Bombing) Planet() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Bombing) Owner() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Bombing) Attacker() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Bombing) Production() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Bombing) Industry() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Bombing) MutateIndustry(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func (rcv *Bombing) Population() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Bombing) MutatePopulation(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(16, n)
+}
+
+func (rcv *Bombing) Colonists() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Bombing) MutateColonists(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(18, n)
+}
+
+func (rcv *Bombing) Capital() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Bombing) MutateCapital(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(20, n)
+}
+
+func (rcv *Bombing) Material() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Bombing) MutateMaterial(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(22, n)
+}
+
+func (rcv *Bombing) AttackPower() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Bombing) MutateAttackPower(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(24, n)
+}
+
+func (rcv *Bombing) Wiped() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Bombing) MutateWiped(n bool) bool {
+	return rcv._tab.MutateBoolSlot(26, n)
+}
+
+func BombingStart(builder *flatbuffers.Builder) {
+	builder.StartObject(12)
+}
+func BombingAddNumber(builder *flatbuffers.Builder, number uint64) {
+	builder.PrependUint64Slot(0, number, 0)
+}
+func BombingAddPlanet(builder *flatbuffers.Builder, planet flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(planet), 0)
+}
+func BombingAddOwner(builder *flatbuffers.Builder, owner flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(owner), 0)
+}
+func BombingAddAttacker(builder *flatbuffers.Builder, attacker flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(attacker), 0)
+}
+func BombingAddProduction(builder *flatbuffers.Builder, production flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(production), 0)
+}
+func BombingAddIndustry(builder *flatbuffers.Builder, industry float32) {
+	builder.PrependFloat32Slot(5, industry, 0.0)
+}
+func BombingAddPopulation(builder *flatbuffers.Builder, population float32) {
+	builder.PrependFloat32Slot(6, population, 0.0)
+}
+func BombingAddColonists(builder *flatbuffers.Builder, colonists float32) {
+	builder.PrependFloat32Slot(7, colonists, 0.0)
+}
+func BombingAddCapital(builder *flatbuffers.Builder, capital float32) {
+	builder.PrependFloat32Slot(8, capital, 0.0)
+}
+func BombingAddMaterial(builder *flatbuffers.Builder, material float32) {
+	builder.PrependFloat32Slot(9, material, 0.0)
+}
+func BombingAddAttackPower(builder *flatbuffers.Builder, attackPower float32) {
+	builder.PrependFloat32Slot(10, attackPower, 0.0)
+}
+func BombingAddWiped(builder *flatbuffers.Builder, wiped bool) {
+	builder.PrependBoolSlot(11, wiped, false)
+}
+func BombingEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/IncomingGroup.go

@@ -0,0 +1,124 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type IncomingGroup struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsIncomingGroup(buf []byte, offset flatbuffers.UOffsetT) *IncomingGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &IncomingGroup{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishIncomingGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsIncomingGroup(buf []byte, offset flatbuffers.UOffsetT) *IncomingGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &IncomingGroup{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedIncomingGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *IncomingGroup) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *IncomingGroup) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *IncomingGroup) Origin() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *IncomingGroup) MutateOrigin(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *IncomingGroup) Destination() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *IncomingGroup) MutateDestination(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(6, n)
+}
+
+func (rcv *IncomingGroup) Distance() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *IncomingGroup) MutateDistance(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(8, n)
+}
+
+func (rcv *IncomingGroup) Speed() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *IncomingGroup) MutateSpeed(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *IncomingGroup) Mass() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *IncomingGroup) MutateMass(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func IncomingGroupStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func IncomingGroupAddOrigin(builder *flatbuffers.Builder, origin uint64) {
+	builder.PrependUint64Slot(0, origin, 0)
+}
+func IncomingGroupAddDestination(builder *flatbuffers.Builder, destination uint64) {
+	builder.PrependUint64Slot(1, destination, 0)
+}
+func IncomingGroupAddDistance(builder *flatbuffers.Builder, distance float32) {
+	builder.PrependFloat32Slot(2, distance, 0.0)
+}
+func IncomingGroupAddSpeed(builder *flatbuffers.Builder, speed float32) {
+	builder.PrependFloat32Slot(3, speed, 0.0)
+}
+func IncomingGroupAddMass(builder *flatbuffers.Builder, mass float32) {
+	builder.PrependFloat32Slot(4, mass, 0.0)
+}
+func IncomingGroupEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/LocalFleet.go

@@ -0,0 +1,150 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type LocalFleet struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsLocalFleet(buf []byte, offset flatbuffers.UOffsetT) *LocalFleet {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &LocalFleet{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishLocalFleetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsLocalFleet(buf []byte, offset flatbuffers.UOffsetT) *LocalFleet {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &LocalFleet{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedLocalFleetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *LocalFleet) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *LocalFleet) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *LocalFleet) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *LocalFleet) Groups() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *LocalFleet) MutateGroups(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(6, n)
+}
+
+func (rcv *LocalFleet) Destination() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *LocalFleet) MutateDestination(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(8, n)
+}
+
+func (rcv *LocalFleet) Origin() *uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		v := rcv._tab.GetUint64(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *LocalFleet) MutateOrigin(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(10, n)
+}
+
+func (rcv *LocalFleet) Range() *float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		v := rcv._tab.GetFloat32(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *LocalFleet) MutateRange(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *LocalFleet) Speed() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalFleet) MutateSpeed(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func (rcv *LocalFleet) State() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func LocalFleetStart(builder *flatbuffers.Builder) {
+	builder.StartObject(7)
+}
+func LocalFleetAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func LocalFleetAddGroups(builder *flatbuffers.Builder, groups uint64) {
+	builder.PrependUint64Slot(1, groups, 0)
+}
+func LocalFleetAddDestination(builder *flatbuffers.Builder, destination uint64) {
+	builder.PrependUint64Slot(2, destination, 0)
+}
+func LocalFleetAddOrigin(builder *flatbuffers.Builder, origin uint64) {
+	builder.PrependUint64(origin)
+	builder.Slot(3)
+}
+func LocalFleetAddRange(builder *flatbuffers.Builder, range_ float32) {
+	builder.PrependFloat32(range_)
+	builder.Slot(4)
+}
+func LocalFleetAddSpeed(builder *flatbuffers.Builder, speed float32) {
+	builder.PrependFloat32Slot(5, speed, 0.0)
+}
+func LocalFleetAddState(builder *flatbuffers.Builder, state flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(state), 0)
+}
+func LocalFleetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/LocalGroup.go

@@ -0,0 +1,244 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type LocalGroup struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsLocalGroup(buf []byte, offset flatbuffers.UOffsetT) *LocalGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &LocalGroup{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishLocalGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsLocalGroup(buf []byte, offset flatbuffers.UOffsetT) *LocalGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &LocalGroup{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedLocalGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *LocalGroup) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *LocalGroup) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *LocalGroup) Number() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *LocalGroup) MutateNumber(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *LocalGroup) Class() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *LocalGroup) Tech(obj *TechEntry, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *LocalGroup) TechLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *LocalGroup) Cargo() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *LocalGroup) Load() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalGroup) MutateLoad(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *LocalGroup) Destination() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *LocalGroup) MutateDestination(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(14, n)
+}
+
+func (rcv *LocalGroup) Origin() *uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		v := rcv._tab.GetUint64(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *LocalGroup) MutateOrigin(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(16, n)
+}
+
+func (rcv *LocalGroup) Range() *float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		v := rcv._tab.GetFloat32(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *LocalGroup) MutateRange(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(18, n)
+}
+
+func (rcv *LocalGroup) Speed() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalGroup) MutateSpeed(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(20, n)
+}
+
+func (rcv *LocalGroup) Mass() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalGroup) MutateMass(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(22, n)
+}
+
+func (rcv *LocalGroup) Id(obj *UUID) *UUID {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		x := o + rcv._tab.Pos
+		if obj == nil {
+			obj = new(UUID)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *LocalGroup) State() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *LocalGroup) Fleet() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func LocalGroupStart(builder *flatbuffers.Builder) {
+	builder.StartObject(13)
+}
+func LocalGroupAddNumber(builder *flatbuffers.Builder, number uint64) {
+	builder.PrependUint64Slot(0, number, 0)
+}
+func LocalGroupAddClass(builder *flatbuffers.Builder, class flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(class), 0)
+}
+func LocalGroupAddTech(builder *flatbuffers.Builder, tech flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(tech), 0)
+}
+func LocalGroupStartTechVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func LocalGroupAddCargo(builder *flatbuffers.Builder, cargo flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(cargo), 0)
+}
+func LocalGroupAddLoad(builder *flatbuffers.Builder, load float32) {
+	builder.PrependFloat32Slot(4, load, 0.0)
+}
+func LocalGroupAddDestination(builder *flatbuffers.Builder, destination uint64) {
+	builder.PrependUint64Slot(5, destination, 0)
+}
+func LocalGroupAddOrigin(builder *flatbuffers.Builder, origin uint64) {
+	builder.PrependUint64(origin)
+	builder.Slot(6)
+}
+func LocalGroupAddRange(builder *flatbuffers.Builder, range_ float32) {
+	builder.PrependFloat32(range_)
+	builder.Slot(7)
+}
+func LocalGroupAddSpeed(builder *flatbuffers.Builder, speed float32) {
+	builder.PrependFloat32Slot(8, speed, 0.0)
+}
+func LocalGroupAddMass(builder *flatbuffers.Builder, mass float32) {
+	builder.PrependFloat32Slot(9, mass, 0.0)
+}
+func LocalGroupAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependStructSlot(10, flatbuffers.UOffsetT(id), 0)
+}
+func LocalGroupAddState(builder *flatbuffers.Builder, state flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(state), 0)
+}
+func LocalGroupAddFleet(builder *flatbuffers.Builder, fleet flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(fleet), 0)
+}
+func LocalGroupEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/LocalPlanet.go

@@ -0,0 +1,236 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type LocalPlanet struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsLocalPlanet(buf []byte, offset flatbuffers.UOffsetT) *LocalPlanet {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &LocalPlanet{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishLocalPlanetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsLocalPlanet(buf []byte, offset flatbuffers.UOffsetT) *LocalPlanet {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &LocalPlanet{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedLocalPlanetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *LocalPlanet) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *LocalPlanet) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *LocalPlanet) X() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateX(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(4, n)
+}
+
+func (rcv *LocalPlanet) Y() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateY(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func (rcv *LocalPlanet) Number() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *LocalPlanet) MutateNumber(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(8, n)
+}
+
+func (rcv *LocalPlanet) Size() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateSize(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *LocalPlanet) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *LocalPlanet) Resources() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateResources(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func (rcv *LocalPlanet) Capital() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateCapital(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(16, n)
+}
+
+func (rcv *LocalPlanet) Material() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateMaterial(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(18, n)
+}
+
+func (rcv *LocalPlanet) Industry() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateIndustry(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(20, n)
+}
+
+func (rcv *LocalPlanet) Population() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutatePopulation(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(22, n)
+}
+
+func (rcv *LocalPlanet) Colonists() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateColonists(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(24, n)
+}
+
+func (rcv *LocalPlanet) Production() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *LocalPlanet) FreeIndustry() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *LocalPlanet) MutateFreeIndustry(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(28, n)
+}
+
+func LocalPlanetStart(builder *flatbuffers.Builder) {
+	builder.StartObject(13)
+}
+func LocalPlanetAddX(builder *flatbuffers.Builder, x float32) {
+	builder.PrependFloat32Slot(0, x, 0.0)
+}
+func LocalPlanetAddY(builder *flatbuffers.Builder, y float32) {
+	builder.PrependFloat32Slot(1, y, 0.0)
+}
+func LocalPlanetAddNumber(builder *flatbuffers.Builder, number uint64) {
+	builder.PrependUint64Slot(2, number, 0)
+}
+func LocalPlanetAddSize(builder *flatbuffers.Builder, size float32) {
+	builder.PrependFloat32Slot(3, size, 0.0)
+}
+func LocalPlanetAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(name), 0)
+}
+func LocalPlanetAddResources(builder *flatbuffers.Builder, resources float32) {
+	builder.PrependFloat32Slot(5, resources, 0.0)
+}
+func LocalPlanetAddCapital(builder *flatbuffers.Builder, capital float32) {
+	builder.PrependFloat32Slot(6, capital, 0.0)
+}
+func LocalPlanetAddMaterial(builder *flatbuffers.Builder, material float32) {
+	builder.PrependFloat32Slot(7, material, 0.0)
+}
+func LocalPlanetAddIndustry(builder *flatbuffers.Builder, industry float32) {
+	builder.PrependFloat32Slot(8, industry, 0.0)
+}
+func LocalPlanetAddPopulation(builder *flatbuffers.Builder, population float32) {
+	builder.PrependFloat32Slot(9, population, 0.0)
+}
+func LocalPlanetAddColonists(builder *flatbuffers.Builder, colonists float32) {
+	builder.PrependFloat32Slot(10, colonists, 0.0)
+}
+func LocalPlanetAddProduction(builder *flatbuffers.Builder, production flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(production), 0)
+}
+func LocalPlanetAddFreeIndustry(builder *flatbuffers.Builder, freeIndustry float32) {
+	builder.PrependFloat32Slot(12, freeIndustry, 0.0)
+}
+func LocalPlanetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/OtherGroup.go

@@ -0,0 +1,206 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type OtherGroup struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOtherGroup(buf []byte, offset flatbuffers.UOffsetT) *OtherGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OtherGroup{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOtherGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOtherGroup(buf []byte, offset flatbuffers.UOffsetT) *OtherGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OtherGroup{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOtherGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OtherGroup) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OtherGroup) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OtherGroup) Number() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *OtherGroup) MutateNumber(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *OtherGroup) Class() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OtherGroup) Tech(obj *TechEntry, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *OtherGroup) TechLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *OtherGroup) Cargo() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OtherGroup) Load() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherGroup) MutateLoad(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *OtherGroup) Destination() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *OtherGroup) MutateDestination(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(14, n)
+}
+
+func (rcv *OtherGroup) Origin() *uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		v := rcv._tab.GetUint64(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *OtherGroup) MutateOrigin(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(16, n)
+}
+
+func (rcv *OtherGroup) Range() *float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		v := rcv._tab.GetFloat32(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *OtherGroup) MutateRange(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(18, n)
+}
+
+func (rcv *OtherGroup) Speed() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherGroup) MutateSpeed(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(20, n)
+}
+
+func (rcv *OtherGroup) Mass() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherGroup) MutateMass(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(22, n)
+}
+
+func OtherGroupStart(builder *flatbuffers.Builder) {
+	builder.StartObject(10)
+}
+func OtherGroupAddNumber(builder *flatbuffers.Builder, number uint64) {
+	builder.PrependUint64Slot(0, number, 0)
+}
+func OtherGroupAddClass(builder *flatbuffers.Builder, class flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(class), 0)
+}
+func OtherGroupAddTech(builder *flatbuffers.Builder, tech flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(tech), 0)
+}
+func OtherGroupStartTechVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func OtherGroupAddCargo(builder *flatbuffers.Builder, cargo flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(cargo), 0)
+}
+func OtherGroupAddLoad(builder *flatbuffers.Builder, load float32) {
+	builder.PrependFloat32Slot(4, load, 0.0)
+}
+func OtherGroupAddDestination(builder *flatbuffers.Builder, destination uint64) {
+	builder.PrependUint64Slot(5, destination, 0)
+}
+func OtherGroupAddOrigin(builder *flatbuffers.Builder, origin uint64) {
+	builder.PrependUint64(origin)
+	builder.Slot(6)
+}
+func OtherGroupAddRange(builder *flatbuffers.Builder, range_ float32) {
+	builder.PrependFloat32(range_)
+	builder.Slot(7)
+}
+func OtherGroupAddSpeed(builder *flatbuffers.Builder, speed float32) {
+	builder.PrependFloat32Slot(8, speed, 0.0)
+}
+func OtherGroupAddMass(builder *flatbuffers.Builder, mass float32) {
+	builder.PrependFloat32Slot(9, mass, 0.0)
+}
+func OtherGroupEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/OtherPlanet.go

@@ -0,0 +1,247 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type OtherPlanet struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOtherPlanet(buf []byte, offset flatbuffers.UOffsetT) *OtherPlanet {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OtherPlanet{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOtherPlanetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOtherPlanet(buf []byte, offset flatbuffers.UOffsetT) *OtherPlanet {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OtherPlanet{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOtherPlanetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OtherPlanet) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OtherPlanet) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OtherPlanet) Owner() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OtherPlanet) X() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateX(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func (rcv *OtherPlanet) Y() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateY(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(8, n)
+}
+
+func (rcv *OtherPlanet) Number() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *OtherPlanet) MutateNumber(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(10, n)
+}
+
+func (rcv *OtherPlanet) Size() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateSize(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *OtherPlanet) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OtherPlanet) Resources() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateResources(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(16, n)
+}
+
+func (rcv *OtherPlanet) Capital() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateCapital(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(18, n)
+}
+
+func (rcv *OtherPlanet) Material() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateMaterial(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(20, n)
+}
+
+func (rcv *OtherPlanet) Industry() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateIndustry(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(22, n)
+}
+
+func (rcv *OtherPlanet) Population() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutatePopulation(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(24, n)
+}
+
+func (rcv *OtherPlanet) Colonists() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateColonists(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(26, n)
+}
+
+func (rcv *OtherPlanet) Production() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OtherPlanet) FreeIndustry() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherPlanet) MutateFreeIndustry(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(30, n)
+}
+
+func OtherPlanetStart(builder *flatbuffers.Builder) {
+	builder.StartObject(14)
+}
+func OtherPlanetAddOwner(builder *flatbuffers.Builder, owner flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(owner), 0)
+}
+func OtherPlanetAddX(builder *flatbuffers.Builder, x float32) {
+	builder.PrependFloat32Slot(1, x, 0.0)
+}
+func OtherPlanetAddY(builder *flatbuffers.Builder, y float32) {
+	builder.PrependFloat32Slot(2, y, 0.0)
+}
+func OtherPlanetAddNumber(builder *flatbuffers.Builder, number uint64) {
+	builder.PrependUint64Slot(3, number, 0)
+}
+func OtherPlanetAddSize(builder *flatbuffers.Builder, size float32) {
+	builder.PrependFloat32Slot(4, size, 0.0)
+}
+func OtherPlanetAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(name), 0)
+}
+func OtherPlanetAddResources(builder *flatbuffers.Builder, resources float32) {
+	builder.PrependFloat32Slot(6, resources, 0.0)
+}
+func OtherPlanetAddCapital(builder *flatbuffers.Builder, capital float32) {
+	builder.PrependFloat32Slot(7, capital, 0.0)
+}
+func OtherPlanetAddMaterial(builder *flatbuffers.Builder, material float32) {
+	builder.PrependFloat32Slot(8, material, 0.0)
+}
+func OtherPlanetAddIndustry(builder *flatbuffers.Builder, industry float32) {
+	builder.PrependFloat32Slot(9, industry, 0.0)
+}
+func OtherPlanetAddPopulation(builder *flatbuffers.Builder, population float32) {
+	builder.PrependFloat32Slot(10, population, 0.0)
+}
+func OtherPlanetAddColonists(builder *flatbuffers.Builder, colonists float32) {
+	builder.PrependFloat32Slot(11, colonists, 0.0)
+}
+func OtherPlanetAddProduction(builder *flatbuffers.Builder, production flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(production), 0)
+}
+func OtherPlanetAddFreeIndustry(builder *flatbuffers.Builder, freeIndustry float32) {
+	builder.PrependFloat32Slot(13, freeIndustry, 0.0)
+}
+func OtherPlanetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/OtherScience.go

@@ -0,0 +1,131 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type OtherScience struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOtherScience(buf []byte, offset flatbuffers.UOffsetT) *OtherScience {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OtherScience{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOtherScienceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOtherScience(buf []byte, offset flatbuffers.UOffsetT) *OtherScience {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OtherScience{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOtherScienceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OtherScience) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OtherScience) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OtherScience) Race() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OtherScience) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OtherScience) Drive() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherScience) MutateDrive(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(8, n)
+}
+
+func (rcv *OtherScience) Weapons() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherScience) MutateWeapons(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *OtherScience) Shields() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherScience) MutateShields(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *OtherScience) Cargo() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OtherScience) MutateCargo(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func OtherScienceStart(builder *flatbuffers.Builder) {
+	builder.StartObject(6)
+}
+func OtherScienceAddRace(builder *flatbuffers.Builder, race flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(race), 0)
+}
+func OtherScienceAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(name), 0)
+}
+func OtherScienceAddDrive(builder *flatbuffers.Builder, drive float32) {
+	builder.PrependFloat32Slot(2, drive, 0.0)
+}
+func OtherScienceAddWeapons(builder *flatbuffers.Builder, weapons float32) {
+	builder.PrependFloat32Slot(3, weapons, 0.0)
+}
+func OtherScienceAddShields(builder *flatbuffers.Builder, shields float32) {
+	builder.PrependFloat32Slot(4, shields, 0.0)
+}
+func OtherScienceAddCargo(builder *flatbuffers.Builder, cargo float32) {
+	builder.PrependFloat32Slot(5, cargo, 0.0)
+}
+func OtherScienceEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/OthersShipClass.go

@@ -0,0 +1,161 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type OthersShipClass struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsOthersShipClass(buf []byte, offset flatbuffers.UOffsetT) *OthersShipClass {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &OthersShipClass{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishOthersShipClassBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsOthersShipClass(buf []byte, offset flatbuffers.UOffsetT) *OthersShipClass {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &OthersShipClass{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedOthersShipClassBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *OthersShipClass) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *OthersShipClass) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *OthersShipClass) Race() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OthersShipClass) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *OthersShipClass) Drive() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OthersShipClass) MutateDrive(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(8, n)
+}
+
+func (rcv *OthersShipClass) Armament() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *OthersShipClass) MutateArmament(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(10, n)
+}
+
+func (rcv *OthersShipClass) Weapons() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OthersShipClass) MutateWeapons(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *OthersShipClass) Shields() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OthersShipClass) MutateShields(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func (rcv *OthersShipClass) Cargo() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OthersShipClass) MutateCargo(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(16, n)
+}
+
+func (rcv *OthersShipClass) Mass() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *OthersShipClass) MutateMass(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(18, n)
+}
+
+func OthersShipClassStart(builder *flatbuffers.Builder) {
+	builder.StartObject(8)
+}
+func OthersShipClassAddRace(builder *flatbuffers.Builder, race flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(race), 0)
+}
+func OthersShipClassAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(name), 0)
+}
+func OthersShipClassAddDrive(builder *flatbuffers.Builder, drive float32) {
+	builder.PrependFloat32Slot(2, drive, 0.0)
+}
+func OthersShipClassAddArmament(builder *flatbuffers.Builder, armament uint64) {
+	builder.PrependUint64Slot(3, armament, 0)
+}
+func OthersShipClassAddWeapons(builder *flatbuffers.Builder, weapons float32) {
+	builder.PrependFloat32Slot(4, weapons, 0.0)
+}
+func OthersShipClassAddShields(builder *flatbuffers.Builder, shields float32) {
+	builder.PrependFloat32Slot(5, shields, 0.0)
+}
+func OthersShipClassAddCargo(builder *flatbuffers.Builder, cargo float32) {
+	builder.PrependFloat32Slot(6, cargo, 0.0)
+}
+func OthersShipClassAddMass(builder *flatbuffers.Builder, mass float32) {
+	builder.PrependFloat32Slot(7, mass, 0.0)
+}
+func OthersShipClassEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/Player.go

@@ -0,0 +1,206 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Player struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsPlayer(buf []byte, offset flatbuffers.UOffsetT) *Player {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Player{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishPlayerBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsPlayer(buf []byte, offset flatbuffers.UOffsetT) *Player {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Player{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedPlayerBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Player) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Player) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Player) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Player) Drive() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Player) MutateDrive(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func (rcv *Player) Weapons() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Player) MutateWeapons(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(8, n)
+}
+
+func (rcv *Player) Shields() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Player) MutateShields(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *Player) Cargo() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Player) MutateCargo(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *Player) Population() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Player) MutatePopulation(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func (rcv *Player) Industry() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Player) MutateIndustry(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(16, n)
+}
+
+func (rcv *Player) Planets() uint16 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetUint16(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Player) MutatePlanets(n uint16) bool {
+	return rcv._tab.MutateUint16Slot(18, n)
+}
+
+func (rcv *Player) Relation() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Player) Votes() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Player) MutateVotes(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(22, n)
+}
+
+func (rcv *Player) Extinct() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *Player) MutateExtinct(n bool) bool {
+	return rcv._tab.MutateBoolSlot(24, n)
+}
+
+func PlayerStart(builder *flatbuffers.Builder) {
+	builder.StartObject(11)
+}
+func PlayerAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func PlayerAddDrive(builder *flatbuffers.Builder, drive float32) {
+	builder.PrependFloat32Slot(1, drive, 0.0)
+}
+func PlayerAddWeapons(builder *flatbuffers.Builder, weapons float32) {
+	builder.PrependFloat32Slot(2, weapons, 0.0)
+}
+func PlayerAddShields(builder *flatbuffers.Builder, shields float32) {
+	builder.PrependFloat32Slot(3, shields, 0.0)
+}
+func PlayerAddCargo(builder *flatbuffers.Builder, cargo float32) {
+	builder.PrependFloat32Slot(4, cargo, 0.0)
+}
+func PlayerAddPopulation(builder *flatbuffers.Builder, population float32) {
+	builder.PrependFloat32Slot(5, population, 0.0)
+}
+func PlayerAddIndustry(builder *flatbuffers.Builder, industry float32) {
+	builder.PrependFloat32Slot(6, industry, 0.0)
+}
+func PlayerAddPlanets(builder *flatbuffers.Builder, planets uint16) {
+	builder.PrependUint16Slot(7, planets, 0)
+}
+func PlayerAddRelation(builder *flatbuffers.Builder, relation flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(relation), 0)
+}
+func PlayerAddVotes(builder *flatbuffers.Builder, votes float32) {
+	builder.PrependFloat32Slot(9, votes, 0.0)
+}
+func PlayerAddExtinct(builder *flatbuffers.Builder, extinct bool) {
+	builder.PrependBoolSlot(10, extinct, false)
+}
+func PlayerEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/Report.go

@@ -0,0 +1,628 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Report struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsReport(buf []byte, offset flatbuffers.UOffsetT) *Report {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Report{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishReportBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsReport(buf []byte, offset flatbuffers.UOffsetT) *Report {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Report{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedReportBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Report) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Report) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Report) Version() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Report) MutateVersion(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *Report) Turn() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Report) MutateTurn(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(6, n)
+}
+
+func (rcv *Report) Width() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Report) MutateWidth(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(8, n)
+}
+
+func (rcv *Report) Height() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Report) MutateHeight(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(10, n)
+}
+
+func (rcv *Report) PlanetCount() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Report) MutatePlanetCount(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(12, n)
+}
+
+func (rcv *Report) Race() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Report) Votes() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Report) MutateVotes(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(16, n)
+}
+
+func (rcv *Report) VoteFor() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Report) Player(obj *Player, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) PlayerLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) LocalScience(obj *Science, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) LocalScienceLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) OtherScience(obj *OtherScience, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) OtherScienceLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) LocalShipClass(obj *ShipClass, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) LocalShipClassLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) OtherShipClass(obj *OthersShipClass, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) OtherShipClassLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) Battle(obj *UUID, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 16
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) BattleLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) Bombing(obj *Bombing, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) BombingLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) IncomingGroup(obj *IncomingGroup, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(34))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) IncomingGroupLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(34))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) LocalPlanet(obj *LocalPlanet, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(36))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) LocalPlanetLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(36))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) ShipProduction(obj *ShipProduction, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(38))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) ShipProductionLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(38))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) Route(obj *Route, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(40))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) RouteLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(40))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) OtherPlanet(obj *OtherPlanet, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(42))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) OtherPlanetLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(42))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) UninhabitedPlanet(obj *UninhabitedPlanet, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(44))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) UninhabitedPlanetLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(44))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) UnidentifiedPlanet(obj *UnidentifiedPlanet, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(46))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) UnidentifiedPlanetLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(46))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) LocalFleet(obj *LocalFleet, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(48))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) LocalFleetLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(48))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) LocalGroup(obj *LocalGroup, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(50))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) LocalGroupLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(50))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) OtherGroup(obj *OtherGroup, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) OtherGroupLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *Report) UnidentifiedGroup(obj *UnidentifiedGroup, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(54))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Report) UnidentifiedGroupLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(54))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func ReportStart(builder *flatbuffers.Builder) {
+	builder.StartObject(26)
+}
+func ReportAddVersion(builder *flatbuffers.Builder, version uint64) {
+	builder.PrependUint64Slot(0, version, 0)
+}
+func ReportAddTurn(builder *flatbuffers.Builder, turn uint64) {
+	builder.PrependUint64Slot(1, turn, 0)
+}
+func ReportAddWidth(builder *flatbuffers.Builder, width uint32) {
+	builder.PrependUint32Slot(2, width, 0)
+}
+func ReportAddHeight(builder *flatbuffers.Builder, height uint32) {
+	builder.PrependUint32Slot(3, height, 0)
+}
+func ReportAddPlanetCount(builder *flatbuffers.Builder, planetCount uint32) {
+	builder.PrependUint32Slot(4, planetCount, 0)
+}
+func ReportAddRace(builder *flatbuffers.Builder, race flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(race), 0)
+}
+func ReportAddVotes(builder *flatbuffers.Builder, votes float32) {
+	builder.PrependFloat32Slot(6, votes, 0.0)
+}
+func ReportAddVoteFor(builder *flatbuffers.Builder, voteFor flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(voteFor), 0)
+}
+func ReportAddPlayer(builder *flatbuffers.Builder, player flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(player), 0)
+}
+func ReportStartPlayerVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddLocalScience(builder *flatbuffers.Builder, localScience flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(localScience), 0)
+}
+func ReportStartLocalScienceVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddOtherScience(builder *flatbuffers.Builder, otherScience flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(otherScience), 0)
+}
+func ReportStartOtherScienceVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddLocalShipClass(builder *flatbuffers.Builder, localShipClass flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(localShipClass), 0)
+}
+func ReportStartLocalShipClassVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddOtherShipClass(builder *flatbuffers.Builder, otherShipClass flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(otherShipClass), 0)
+}
+func ReportStartOtherShipClassVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddBattle(builder *flatbuffers.Builder, battle flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(13, flatbuffers.UOffsetT(battle), 0)
+}
+func ReportStartBattleVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(16, numElems, 8)
+}
+func ReportAddBombing(builder *flatbuffers.Builder, bombing flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(14, flatbuffers.UOffsetT(bombing), 0)
+}
+func ReportStartBombingVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddIncomingGroup(builder *flatbuffers.Builder, incomingGroup flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(15, flatbuffers.UOffsetT(incomingGroup), 0)
+}
+func ReportStartIncomingGroupVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddLocalPlanet(builder *flatbuffers.Builder, localPlanet flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(16, flatbuffers.UOffsetT(localPlanet), 0)
+}
+func ReportStartLocalPlanetVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddShipProduction(builder *flatbuffers.Builder, shipProduction flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(17, flatbuffers.UOffsetT(shipProduction), 0)
+}
+func ReportStartShipProductionVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddRoute(builder *flatbuffers.Builder, route flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(18, flatbuffers.UOffsetT(route), 0)
+}
+func ReportStartRouteVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddOtherPlanet(builder *flatbuffers.Builder, otherPlanet flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(19, flatbuffers.UOffsetT(otherPlanet), 0)
+}
+func ReportStartOtherPlanetVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddUninhabitedPlanet(builder *flatbuffers.Builder, uninhabitedPlanet flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(20, flatbuffers.UOffsetT(uninhabitedPlanet), 0)
+}
+func ReportStartUninhabitedPlanetVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddUnidentifiedPlanet(builder *flatbuffers.Builder, unidentifiedPlanet flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(21, flatbuffers.UOffsetT(unidentifiedPlanet), 0)
+}
+func ReportStartUnidentifiedPlanetVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddLocalFleet(builder *flatbuffers.Builder, localFleet flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(22, flatbuffers.UOffsetT(localFleet), 0)
+}
+func ReportStartLocalFleetVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddLocalGroup(builder *flatbuffers.Builder, localGroup flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(23, flatbuffers.UOffsetT(localGroup), 0)
+}
+func ReportStartLocalGroupVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddOtherGroup(builder *flatbuffers.Builder, otherGroup flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(24, flatbuffers.UOffsetT(otherGroup), 0)
+}
+func ReportStartOtherGroupVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportAddUnidentifiedGroup(builder *flatbuffers.Builder, unidentifiedGroup flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(25, flatbuffers.UOffsetT(unidentifiedGroup), 0)
+}
+func ReportStartUnidentifiedGroupVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func ReportEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/Route.go

@@ -0,0 +1,90 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Route struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsRoute(buf []byte, offset flatbuffers.UOffsetT) *Route {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Route{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishRouteBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsRoute(buf []byte, offset flatbuffers.UOffsetT) *Route {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Route{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedRouteBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Route) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Route) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Route) Planet() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *Route) MutatePlanet(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *Route) Route(obj *RouteEntry, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *Route) RouteLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func RouteStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func RouteAddPlanet(builder *flatbuffers.Builder, planet uint64) {
+	builder.PrependUint64Slot(0, planet, 0)
+}
+func RouteAddRoute(builder *flatbuffers.Builder, route flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(route), 0)
+}
+func RouteStartRouteVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func RouteEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/RouteEntry.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type RouteEntry struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsRouteEntry(buf []byte, offset flatbuffers.UOffsetT) *RouteEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &RouteEntry{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishRouteEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsRouteEntry(buf []byte, offset flatbuffers.UOffsetT) *RouteEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &RouteEntry{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedRouteEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *RouteEntry) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *RouteEntry) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *RouteEntry) Key() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *RouteEntry) MutateKey(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *RouteEntry) Value() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func RouteEntryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func RouteEntryAddKey(builder *flatbuffers.Builder, key uint64) {
+	builder.PrependUint64Slot(0, key, 0)
+}
+func RouteEntryAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(value), 0)
+}
+func RouteEntryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/Science.go

@@ -0,0 +1,120 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Science struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsScience(buf []byte, offset flatbuffers.UOffsetT) *Science {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &Science{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishScienceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsScience(buf []byte, offset flatbuffers.UOffsetT) *Science {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &Science{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedScienceBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *Science) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Science) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *Science) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *Science) Drive() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Science) MutateDrive(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func (rcv *Science) Weapons() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Science) MutateWeapons(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(8, n)
+}
+
+func (rcv *Science) Shields() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Science) MutateShields(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *Science) Cargo() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *Science) MutateCargo(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func ScienceStart(builder *flatbuffers.Builder) {
+	builder.StartObject(5)
+}
+func ScienceAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func ScienceAddDrive(builder *flatbuffers.Builder, drive float32) {
+	builder.PrependFloat32Slot(1, drive, 0.0)
+}
+func ScienceAddWeapons(builder *flatbuffers.Builder, weapons float32) {
+	builder.PrependFloat32Slot(2, weapons, 0.0)
+}
+func ScienceAddShields(builder *flatbuffers.Builder, shields float32) {
+	builder.PrependFloat32Slot(3, shields, 0.0)
+}
+func ScienceAddCargo(builder *flatbuffers.Builder, cargo float32) {
+	builder.PrependFloat32Slot(4, cargo, 0.0)
+}
+func ScienceEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/ShipClass.go

@@ -0,0 +1,150 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ShipClass struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsShipClass(buf []byte, offset flatbuffers.UOffsetT) *ShipClass {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ShipClass{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishShipClassBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsShipClass(buf []byte, offset flatbuffers.UOffsetT) *ShipClass {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ShipClass{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedShipClassBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ShipClass) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ShipClass) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ShipClass) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ShipClass) Drive() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipClass) MutateDrive(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func (rcv *ShipClass) Armament() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ShipClass) MutateArmament(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(8, n)
+}
+
+func (rcv *ShipClass) Weapons() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipClass) MutateWeapons(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *ShipClass) Shields() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipClass) MutateShields(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *ShipClass) Cargo() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipClass) MutateCargo(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func (rcv *ShipClass) Mass() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipClass) MutateMass(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(16, n)
+}
+
+func ShipClassStart(builder *flatbuffers.Builder) {
+	builder.StartObject(7)
+}
+func ShipClassAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func ShipClassAddDrive(builder *flatbuffers.Builder, drive float32) {
+	builder.PrependFloat32Slot(1, drive, 0.0)
+}
+func ShipClassAddArmament(builder *flatbuffers.Builder, armament uint64) {
+	builder.PrependUint64Slot(2, armament, 0)
+}
+func ShipClassAddWeapons(builder *flatbuffers.Builder, weapons float32) {
+	builder.PrependFloat32Slot(3, weapons, 0.0)
+}
+func ShipClassAddShields(builder *flatbuffers.Builder, shields float32) {
+	builder.PrependFloat32Slot(4, shields, 0.0)
+}
+func ShipClassAddCargo(builder *flatbuffers.Builder, cargo float32) {
+	builder.PrependFloat32Slot(5, cargo, 0.0)
+}
+func ShipClassAddMass(builder *flatbuffers.Builder, mass float32) {
+	builder.PrependFloat32Slot(6, mass, 0.0)
+}
+func ShipClassEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/ShipProduction.go

@@ -0,0 +1,135 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ShipProduction struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsShipProduction(buf []byte, offset flatbuffers.UOffsetT) *ShipProduction {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ShipProduction{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishShipProductionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsShipProduction(buf []byte, offset flatbuffers.UOffsetT) *ShipProduction {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ShipProduction{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedShipProductionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ShipProduction) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ShipProduction) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ShipProduction) Planet() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ShipProduction) MutatePlanet(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(4, n)
+}
+
+func (rcv *ShipProduction) Class() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ShipProduction) Cost() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipProduction) MutateCost(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(8, n)
+}
+
+func (rcv *ShipProduction) ProdUsed() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipProduction) MutateProdUsed(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *ShipProduction) Percent() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipProduction) MutatePercent(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(12, n)
+}
+
+func (rcv *ShipProduction) Free() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ShipProduction) MutateFree(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func ShipProductionStart(builder *flatbuffers.Builder) {
+	builder.StartObject(6)
+}
+func ShipProductionAddPlanet(builder *flatbuffers.Builder, planet uint64) {
+	builder.PrependUint64Slot(0, planet, 0)
+}
+func ShipProductionAddClass(builder *flatbuffers.Builder, class flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(class), 0)
+}
+func ShipProductionAddCost(builder *flatbuffers.Builder, cost float32) {
+	builder.PrependFloat32Slot(2, cost, 0.0)
+}
+func ShipProductionAddProdUsed(builder *flatbuffers.Builder, prodUsed float32) {
+	builder.PrependFloat32Slot(3, prodUsed, 0.0)
+}
+func ShipProductionAddPercent(builder *flatbuffers.Builder, percent float32) {
+	builder.PrependFloat32Slot(4, percent, 0.0)
+}
+func ShipProductionAddFree(builder *flatbuffers.Builder, free float32) {
+	builder.PrependFloat32Slot(5, free, 0.0)
+}
+func ShipProductionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/TechEntry.go

@@ -0,0 +1,75 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type TechEntry struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsTechEntry(buf []byte, offset flatbuffers.UOffsetT) *TechEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &TechEntry{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishTechEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsTechEntry(buf []byte, offset flatbuffers.UOffsetT) *TechEntry {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &TechEntry{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedTechEntryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *TechEntry) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *TechEntry) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *TechEntry) Key() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *TechEntry) Value() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *TechEntry) MutateValue(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func TechEntryStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func TechEntryAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(key), 0)
+}
+func TechEntryAddValue(builder *flatbuffers.Builder, value float32) {
+	builder.PrependFloat32Slot(1, value, 0.0)
+}
+func TechEntryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/UUID.go

@@ -0,0 +1,41 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type UUID struct {
+	_tab flatbuffers.Struct
+}
+
+func (rcv *UUID) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *UUID) Table() flatbuffers.Table {
+	return rcv._tab.Table
+}
+
+func (rcv *UUID) Hi() uint64 {
+	return rcv._tab.GetUint64(rcv._tab.Pos + flatbuffers.UOffsetT(0))
+}
+func (rcv *UUID) MutateHi(n uint64) bool {
+	return rcv._tab.MutateUint64(rcv._tab.Pos+flatbuffers.UOffsetT(0), n)
+}
+
+func (rcv *UUID) Lo() uint64 {
+	return rcv._tab.GetUint64(rcv._tab.Pos + flatbuffers.UOffsetT(8))
+}
+func (rcv *UUID) MutateLo(n uint64) bool {
+	return rcv._tab.MutateUint64(rcv._tab.Pos+flatbuffers.UOffsetT(8), n)
+}
+
+func CreateUUID(builder *flatbuffers.Builder, hi uint64, lo uint64) flatbuffers.UOffsetT {
+	builder.Prep(8, 16)
+	builder.PrependUint64(lo)
+	builder.PrependUint64(hi)
+	return builder.Offset()
+}

pkg/schema/fbs/report/UnidentifiedGroup.go

@@ -0,0 +1,79 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type UnidentifiedGroup struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsUnidentifiedGroup(buf []byte, offset flatbuffers.UOffsetT) *UnidentifiedGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &UnidentifiedGroup{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishUnidentifiedGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUnidentifiedGroup(buf []byte, offset flatbuffers.UOffsetT) *UnidentifiedGroup {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &UnidentifiedGroup{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedUnidentifiedGroupBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *UnidentifiedGroup) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *UnidentifiedGroup) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *UnidentifiedGroup) X() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UnidentifiedGroup) MutateX(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(4, n)
+}
+
+func (rcv *UnidentifiedGroup) Y() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UnidentifiedGroup) MutateY(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func UnidentifiedGroupStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func UnidentifiedGroupAddX(builder *flatbuffers.Builder, x float32) {
+	builder.PrependFloat32Slot(0, x, 0.0)
+}
+func UnidentifiedGroupAddY(builder *flatbuffers.Builder, y float32) {
+	builder.PrependFloat32Slot(1, y, 0.0)
+}
+func UnidentifiedGroupEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/UnidentifiedPlanet.go

@@ -0,0 +1,94 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type UnidentifiedPlanet struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsUnidentifiedPlanet(buf []byte, offset flatbuffers.UOffsetT) *UnidentifiedPlanet {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &UnidentifiedPlanet{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishUnidentifiedPlanetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUnidentifiedPlanet(buf []byte, offset flatbuffers.UOffsetT) *UnidentifiedPlanet {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &UnidentifiedPlanet{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedUnidentifiedPlanetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *UnidentifiedPlanet) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *UnidentifiedPlanet) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *UnidentifiedPlanet) X() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UnidentifiedPlanet) MutateX(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(4, n)
+}
+
+func (rcv *UnidentifiedPlanet) Y() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UnidentifiedPlanet) MutateY(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func (rcv *UnidentifiedPlanet) Number() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *UnidentifiedPlanet) MutateNumber(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(8, n)
+}
+
+func UnidentifiedPlanetStart(builder *flatbuffers.Builder) {
+	builder.StartObject(3)
+}
+func UnidentifiedPlanetAddX(builder *flatbuffers.Builder, x float32) {
+	builder.PrependFloat32Slot(0, x, 0.0)
+}
+func UnidentifiedPlanetAddY(builder *flatbuffers.Builder, y float32) {
+	builder.PrependFloat32Slot(1, y, 0.0)
+}
+func UnidentifiedPlanetAddNumber(builder *flatbuffers.Builder, number uint64) {
+	builder.PrependUint64Slot(2, number, 0)
+}
+func UnidentifiedPlanetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/report/UninhabitedPlanet.go

@@ -0,0 +1,165 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package report
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type UninhabitedPlanet struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsUninhabitedPlanet(buf []byte, offset flatbuffers.UOffsetT) *UninhabitedPlanet {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &UninhabitedPlanet{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishUninhabitedPlanetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUninhabitedPlanet(buf []byte, offset flatbuffers.UOffsetT) *UninhabitedPlanet {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &UninhabitedPlanet{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedUninhabitedPlanetBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *UninhabitedPlanet) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *UninhabitedPlanet) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *UninhabitedPlanet) X() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UninhabitedPlanet) MutateX(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(4, n)
+}
+
+func (rcv *UninhabitedPlanet) Y() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UninhabitedPlanet) MutateY(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(6, n)
+}
+
+func (rcv *UninhabitedPlanet) Number() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *UninhabitedPlanet) MutateNumber(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(8, n)
+}
+
+func (rcv *UninhabitedPlanet) Size() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UninhabitedPlanet) MutateSize(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(10, n)
+}
+
+func (rcv *UninhabitedPlanet) Name() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *UninhabitedPlanet) Resources() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UninhabitedPlanet) MutateResources(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(14, n)
+}
+
+func (rcv *UninhabitedPlanet) Capital() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UninhabitedPlanet) MutateCapital(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(16, n)
+}
+
+func (rcv *UninhabitedPlanet) Material() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *UninhabitedPlanet) MutateMaterial(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(18, n)
+}
+
+func UninhabitedPlanetStart(builder *flatbuffers.Builder) {
+	builder.StartObject(8)
+}
+func UninhabitedPlanetAddX(builder *flatbuffers.Builder, x float32) {
+	builder.PrependFloat32Slot(0, x, 0.0)
+}
+func UninhabitedPlanetAddY(builder *flatbuffers.Builder, y float32) {
+	builder.PrependFloat32Slot(1, y, 0.0)
+}
+func UninhabitedPlanetAddNumber(builder *flatbuffers.Builder, number uint64) {
+	builder.PrependUint64Slot(2, number, 0)
+}
+func UninhabitedPlanetAddSize(builder *flatbuffers.Builder, size float32) {
+	builder.PrependFloat32Slot(3, size, 0.0)
+}
+func UninhabitedPlanetAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(name), 0)
+}
+func UninhabitedPlanetAddResources(builder *flatbuffers.Builder, resources float32) {
+	builder.PrependFloat32Slot(5, resources, 0.0)
+}
+func UninhabitedPlanetAddCapital(builder *flatbuffers.Builder, capital float32) {
+	builder.PrependFloat32Slot(6, capital, 0.0)
+}
+func UninhabitedPlanetAddMaterial(builder *flatbuffers.Builder, material float32) {
+	builder.PrependFloat32Slot(7, material, 0.0)
+}
+func UninhabitedPlanetEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}