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()
+}

pkg/transcoder/battle.go

@@ -0,0 +1,384 @@
+package transcoder
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+
+	model "galaxy/model/report"
+	fbs "galaxy/schema/fbs/battle"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+	"github.com/google/uuid"
+)
+
+// BattleReportToPayload converts model.BattleReport from the internal
+// representation to FlatBuffers bytes that can be sent over network
+// transports.
+//
+// The function returns an error when the input is nil.
+func BattleReportToPayload(report *model.BattleReport) ([]byte, error) {
+	if report == nil {
+		return nil, errors.New("encode battle report payload: report is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(2048)
+
+	planetName := builder.CreateString(report.PlanetName)
+
+	raceOffsets := encodeBattleRaceEntryOffsets(builder, report.Races)
+	shipOffsets := encodeBattleShipEntryOffsets(builder, report.Ships)
+	protocolOffsets := encodeBattleActionOffsets(builder, report.Protocol)
+
+	raceVector := encodeBattleOffsetVector(builder, len(raceOffsets), fbs.BattleReportStartRacesVector, raceOffsets)
+	shipVector := encodeBattleOffsetVector(builder, len(shipOffsets), fbs.BattleReportStartShipsVector, shipOffsets)
+	protocolVector := encodeBattleOffsetVector(builder, len(protocolOffsets), fbs.BattleReportStartProtocolVector, protocolOffsets)
+
+	idHi, idLo := reportUUIDToHiLo(report.ID)
+
+	fbs.BattleReportStart(builder)
+	fbs.BattleReportAddId(builder, fbs.CreateUUID(builder, idHi, idLo))
+	fbs.BattleReportAddPlanet(builder, uint64(report.Planet))
+	fbs.BattleReportAddPlanetName(builder, planetName)
+	if len(raceOffsets) > 0 {
+		fbs.BattleReportAddRaces(builder, raceVector)
+	}
+	if len(shipOffsets) > 0 {
+		fbs.BattleReportAddShips(builder, shipVector)
+	}
+	if len(protocolOffsets) > 0 {
+		fbs.BattleReportAddProtocol(builder, protocolVector)
+	}
+
+	payload := fbs.BattleReportEnd(builder)
+	fbs.FinishBattleReportBuffer(builder, payload)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToBattleReport converts FlatBuffers payload bytes into
+// model.BattleReport.
+//
+// The function validates payload structure and integer conversions.
+// Malformed payloads are returned as errors.
+func PayloadToBattleReport(data []byte) (result *model.BattleReport, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode battle report payload: data is empty")
+	}
+
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			result = nil
+			err = fmt.Errorf("decode battle report payload: panic recovered: %v", recovered)
+		}
+	}()
+
+	flatReport := fbs.GetRootAsBattleReport(data, 0)
+	id := flatReport.Id(nil)
+	if id == nil {
+		return nil, errors.New("decode battle report payload: id is missing")
+	}
+
+	planet, err := uint64ToUint(flatReport.Planet(), "planet")
+	if err != nil {
+		return nil, fmt.Errorf("decode battle report payload: %w", err)
+	}
+
+	result = &model.BattleReport{
+		ID:         reportUUIDFromHiLo(id.Hi(), id.Lo()),
+		Planet:     planet,
+		PlanetName: string(flatReport.PlanetName()),
+	}
+
+	if err := decodeBattleRaceMap(flatReport, result); err != nil {
+		return nil, err
+	}
+	if err := decodeBattleShipMap(flatReport, result); err != nil {
+		return nil, err
+	}
+	if err := decodeBattleProtocol(flatReport, result); err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func encodeBattleRaceEntryOffsets(builder *flatbuffers.Builder, races map[int]uuid.UUID) []flatbuffers.UOffsetT {
+	if len(races) == 0 {
+		return nil
+	}
+
+	keys := make([]int, 0, len(races))
+	for key := range races {
+		keys = append(keys, key)
+	}
+	sort.Ints(keys)
+
+	offsets := make([]flatbuffers.UOffsetT, len(keys))
+	for i, key := range keys {
+		hi, lo := reportUUIDToHiLo(races[key])
+		fbs.RaceEntryStart(builder)
+		fbs.RaceEntryAddKey(builder, int64(key))
+		fbs.RaceEntryAddValue(builder, fbs.CreateUUID(builder, hi, lo))
+		offsets[i] = fbs.RaceEntryEnd(builder)
+	}
+
+	return offsets
+}
+
+func encodeBattleShipEntryOffsets(builder *flatbuffers.Builder, ships map[int]model.BattleReportGroup) []flatbuffers.UOffsetT {
+	if len(ships) == 0 {
+		return nil
+	}
+
+	keys := make([]int, 0, len(ships))
+	for key := range ships {
+		keys = append(keys, key)
+	}
+	sort.Ints(keys)
+
+	offsets := make([]flatbuffers.UOffsetT, len(keys))
+	for i, key := range keys {
+		group := ships[key]
+		groupOffset := encodeBattleReportGroup(builder, &group)
+		fbs.ShipEntryStart(builder)
+		fbs.ShipEntryAddKey(builder, int64(key))
+		fbs.ShipEntryAddValue(builder, groupOffset)
+		offsets[i] = fbs.ShipEntryEnd(builder)
+	}
+
+	return offsets
+}
+
+func encodeBattleActionOffsets(builder *flatbuffers.Builder, protocol []model.BattleActionReport) []flatbuffers.UOffsetT {
+	if len(protocol) == 0 {
+		return nil
+	}
+
+	offsets := make([]flatbuffers.UOffsetT, len(protocol))
+	for i := range protocol {
+		item := &protocol[i]
+		fbs.BattleActionReportStart(builder)
+		fbs.BattleActionReportAddAttacker(builder, int64(item.Attacker))
+		fbs.BattleActionReportAddAttackerShipClass(builder, int64(item.AttackerShipClass))
+		fbs.BattleActionReportAddDefender(builder, int64(item.Defender))
+		fbs.BattleActionReportAddDefenderShipClass(builder, int64(item.DefenderShipClass))
+		fbs.BattleActionReportAddDestroyed(builder, item.Destroyed)
+		offsets[i] = fbs.BattleActionReportEnd(builder)
+	}
+
+	return offsets
+}
+
+func encodeBattleReportGroup(builder *flatbuffers.Builder, group *model.BattleReportGroup) flatbuffers.UOffsetT {
+	race := builder.CreateString(group.Race)
+	className := builder.CreateString(group.ClassName)
+	loadType := builder.CreateString(group.LoadType)
+	tech := encodeBattleTechEntryVector(builder, group.Tech)
+
+	fbs.BattleReportGroupStart(builder)
+	fbs.BattleReportGroupAddInBattle(builder, group.InBattle)
+	fbs.BattleReportGroupAddNumber(builder, uint64(group.Number))
+	fbs.BattleReportGroupAddNumberLeft(builder, uint64(group.NumberLeft))
+	fbs.BattleReportGroupAddLoadQuantity(builder, reportFloatToFBS(group.LoadQuantity))
+	if tech != 0 {
+		fbs.BattleReportGroupAddTech(builder, tech)
+	}
+	fbs.BattleReportGroupAddRace(builder, race)
+	fbs.BattleReportGroupAddClassName(builder, className)
+	fbs.BattleReportGroupAddLoadType(builder, loadType)
+	return fbs.BattleReportGroupEnd(builder)
+}
+
+func encodeBattleTechEntryVector(builder *flatbuffers.Builder, tech map[string]model.Float) flatbuffers.UOffsetT {
+	if len(tech) == 0 {
+		return 0
+	}
+
+	keys := make([]string, 0, len(tech))
+	for key := range tech {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	offsets := make([]flatbuffers.UOffsetT, len(keys))
+	for i, key := range keys {
+		encodedKey := builder.CreateString(key)
+		fbs.TechEntryStart(builder)
+		fbs.TechEntryAddKey(builder, encodedKey)
+		fbs.TechEntryAddValue(builder, reportFloatToFBS(tech[key]))
+		offsets[i] = fbs.TechEntryEnd(builder)
+	}
+
+	fbs.BattleReportGroupStartTechVector(builder, len(offsets))
+	for i := len(offsets) - 1; i >= 0; i-- {
+		builder.PrependUOffsetT(offsets[i])
+	}
+	return builder.EndVector(len(offsets))
+}
+
+func decodeBattleRaceMap(flatReport *fbs.BattleReport, result *model.BattleReport) error {
+	length := flatReport.RacesLength()
+	if length == 0 {
+		return nil
+	}
+
+	result.Races = make(map[int]uuid.UUID, length)
+	item := new(fbs.RaceEntry)
+	for i := 0; i < length; i++ {
+		if !flatReport.Races(item, i) {
+			return fmt.Errorf("decode battle report race %d: race entry is missing", i)
+		}
+
+		key, err := int64ToInt(item.Key(), "race key")
+		if err != nil {
+			return fmt.Errorf("decode battle report race %d: %w", i, err)
+		}
+
+		value := item.Value(nil)
+		if value == nil {
+			return fmt.Errorf("decode battle report race %d: race value is missing", i)
+		}
+
+		result.Races[key] = reportUUIDFromHiLo(value.Hi(), value.Lo())
+	}
+
+	return nil
+}
+
+func decodeBattleShipMap(flatReport *fbs.BattleReport, result *model.BattleReport) error {
+	length := flatReport.ShipsLength()
+	if length == 0 {
+		return nil
+	}
+
+	result.Ships = make(map[int]model.BattleReportGroup, length)
+	item := new(fbs.ShipEntry)
+	for i := 0; i < length; i++ {
+		if !flatReport.Ships(item, i) {
+			return fmt.Errorf("decode battle report ship %d: ship entry is missing", i)
+		}
+
+		key, err := int64ToInt(item.Key(), "ship key")
+		if err != nil {
+			return fmt.Errorf("decode battle report ship %d: %w", i, err)
+		}
+
+		value := item.Value(nil)
+		if value == nil {
+			return fmt.Errorf("decode battle report ship %d: ship value is missing", i)
+		}
+
+		group, err := decodeBattleReportGroup(value, i)
+		if err != nil {
+			return err
+		}
+		result.Ships[key] = group
+	}
+
+	return nil
+}
+
+func decodeBattleProtocol(flatReport *fbs.BattleReport, result *model.BattleReport) error {
+	length := flatReport.ProtocolLength()
+	if length == 0 {
+		return nil
+	}
+
+	result.Protocol = make([]model.BattleActionReport, length)
+	item := new(fbs.BattleActionReport)
+	for i := 0; i < length; i++ {
+		if !flatReport.Protocol(item, i) {
+			return fmt.Errorf("decode battle report protocol %d: protocol entry is missing", i)
+		}
+
+		attacker, err := int64ToInt(item.Attacker(), "attacker")
+		if err != nil {
+			return fmt.Errorf("decode battle report protocol %d: %w", i, err)
+		}
+		attackerShipClass, err := int64ToInt(item.AttackerShipClass(), "attacker_ship_class")
+		if err != nil {
+			return fmt.Errorf("decode battle report protocol %d: %w", i, err)
+		}
+		defender, err := int64ToInt(item.Defender(), "defender")
+		if err != nil {
+			return fmt.Errorf("decode battle report protocol %d: %w", i, err)
+		}
+		defenderShipClass, err := int64ToInt(item.DefenderShipClass(), "defender_ship_class")
+		if err != nil {
+			return fmt.Errorf("decode battle report protocol %d: %w", i, err)
+		}
+
+		result.Protocol[i] = model.BattleActionReport{
+			Attacker:          attacker,
+			AttackerShipClass: attackerShipClass,
+			Defender:          defender,
+			DefenderShipClass: defenderShipClass,
+			Destroyed:         item.Destroyed(),
+		}
+	}
+
+	return nil
+}
+
+func decodeBattleReportGroup(group *fbs.BattleReportGroup, shipIndex int) (model.BattleReportGroup, error) {
+	number, err := uint64ToUint(group.Number(), "number")
+	if err != nil {
+		return model.BattleReportGroup{}, fmt.Errorf("decode battle report ship %d: %w", shipIndex, err)
+	}
+	numberLeft, err := uint64ToUint(group.NumberLeft(), "number_left")
+	if err != nil {
+		return model.BattleReportGroup{}, fmt.Errorf("decode battle report ship %d: %w", shipIndex, err)
+	}
+
+	tech, err := decodeBattleTechMap(group, shipIndex)
+	if err != nil {
+		return model.BattleReportGroup{}, err
+	}
+
+	return model.BattleReportGroup{
+		InBattle:     group.InBattle(),
+		Number:       number,
+		NumberLeft:   numberLeft,
+		LoadQuantity: reportFloatFromFBS(group.LoadQuantity()),
+		Tech:         tech,
+		Race:         string(group.Race()),
+		ClassName:    string(group.ClassName()),
+		LoadType:     string(group.LoadType()),
+	}, nil
+}
+
+func decodeBattleTechMap(group *fbs.BattleReportGroup, shipIndex int) (map[string]model.Float, error) {
+	length := group.TechLength()
+	if length == 0 {
+		return nil, nil
+	}
+
+	result := make(map[string]model.Float, length)
+	item := new(fbs.TechEntry)
+	for i := 0; i < length; i++ {
+		if !group.Tech(item, i) {
+			return nil, fmt.Errorf("decode battle report ship %d tech entry %d: tech entry is missing", shipIndex, i)
+		}
+		result[string(item.Key())] = reportFloatFromFBS(item.Value())
+	}
+
+	return result, nil
+}
+
+func encodeBattleOffsetVector(
+	builder *flatbuffers.Builder,
+	length int,
+	startVector func(*flatbuffers.Builder, int) flatbuffers.UOffsetT,
+	offsets []flatbuffers.UOffsetT,
+) flatbuffers.UOffsetT {
+	if length == 0 {
+		return 0
+	}
+
+	startVector(builder, length)
+	for i := length - 1; i >= 0; i-- {
+		builder.PrependUOffsetT(offsets[i])
+	}
+	return builder.EndVector(length)
+}

pkg/transcoder/battle_test.go

@@ -0,0 +1,275 @@
+package transcoder
+
+import (
+	"bytes"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	model "galaxy/model/report"
+	fbs "galaxy/schema/fbs/battle"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+	"github.com/google/uuid"
+)
+
+func TestBattleReportToPayloadAndPayloadToBattleReportRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	source := sampleBattleReport()
+
+	payload, err := BattleReportToPayload(source)
+	if err != nil {
+		t.Fatalf("encode battle report payload: %v", err)
+	}
+
+	decoded, err := PayloadToBattleReport(payload)
+	if err != nil {
+		t.Fatalf("decode battle report payload: %v", err)
+	}
+
+	expected := battleReportWireClone(t, source)
+	if !reflect.DeepEqual(expected, decoded) {
+		t.Fatalf("round-trip mismatch\nexpected: %#v\ndecoded:  %#v", expected, decoded)
+	}
+}
+
+func TestBattleReportToPayloadNilReport(t *testing.T) {
+	t.Parallel()
+
+	_, err := BattleReportToPayload(nil)
+	if err == nil {
+		t.Fatal("expected error for nil battle report")
+	}
+}
+
+func TestPayloadToBattleReportEmptyData(t *testing.T) {
+	t.Parallel()
+
+	_, err := PayloadToBattleReport(nil)
+	if err == nil {
+		t.Fatal("expected error for empty payload")
+	}
+}
+
+func TestPayloadToBattleReportGarbageDataDoesNotPanic(t *testing.T) {
+	t.Parallel()
+
+	_, err := PayloadToBattleReport([]byte{0x01, 0x02, 0x03})
+	if err == nil {
+		t.Fatal("expected error for malformed payload")
+	}
+}
+
+func TestPayloadToBattleReportMissingID(t *testing.T) {
+	t.Parallel()
+
+	payload := buildBattleReportPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		fbs.BattleReportStart(builder)
+		fbs.BattleReportAddPlanet(builder, 7)
+		return fbs.BattleReportEnd(builder)
+	})
+
+	_, err := PayloadToBattleReport(payload)
+	if err == nil {
+		t.Fatal("expected error for missing battle report id")
+	}
+	if !strings.Contains(err.Error(), "id is missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToBattleReportMissingRaceValue(t *testing.T) {
+	t.Parallel()
+
+	payload := buildBattleReportPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		fbs.RaceEntryStart(builder)
+		fbs.RaceEntryAddKey(builder, 1)
+		race := fbs.RaceEntryEnd(builder)
+
+		fbs.BattleReportStartRacesVector(builder, 1)
+		builder.PrependUOffsetT(race)
+		races := builder.EndVector(1)
+
+		fbs.BattleReportStart(builder)
+		fbs.BattleReportAddId(builder, fbs.CreateUUID(builder, 1, 2))
+		fbs.BattleReportAddRaces(builder, races)
+		return fbs.BattleReportEnd(builder)
+	})
+
+	_, err := PayloadToBattleReport(payload)
+	if err == nil {
+		t.Fatal("expected error for missing race value")
+	}
+	if !strings.Contains(err.Error(), "race value is missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToBattleReportMissingShipValue(t *testing.T) {
+	t.Parallel()
+
+	payload := buildBattleReportPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		fbs.ShipEntryStart(builder)
+		fbs.ShipEntryAddKey(builder, 1)
+		ship := fbs.ShipEntryEnd(builder)
+
+		fbs.BattleReportStartShipsVector(builder, 1)
+		builder.PrependUOffsetT(ship)
+		ships := builder.EndVector(1)
+
+		fbs.BattleReportStart(builder)
+		fbs.BattleReportAddId(builder, fbs.CreateUUID(builder, 1, 2))
+		fbs.BattleReportAddShips(builder, ships)
+		return fbs.BattleReportEnd(builder)
+	})
+
+	_, err := PayloadToBattleReport(payload)
+	if err == nil {
+		t.Fatal("expected error for missing ship value")
+	}
+	if !strings.Contains(err.Error(), "ship value is missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToBattleReportOverflowInt(t *testing.T) {
+	t.Parallel()
+
+	if strconv.IntSize == 64 {
+		t.Skip("int overflow from int64 is not possible on 64-bit runtime")
+	}
+
+	maxInt := int(^uint(0) >> 1)
+	overflowValue := int64(maxInt) + 1
+	payload := buildBattleReportPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		fbs.BattleActionReportStart(builder)
+		fbs.BattleActionReportAddAttacker(builder, overflowValue)
+		protocol := fbs.BattleActionReportEnd(builder)
+
+		fbs.BattleReportStartProtocolVector(builder, 1)
+		builder.PrependUOffsetT(protocol)
+		protocolVector := builder.EndVector(1)
+
+		fbs.BattleReportStart(builder)
+		fbs.BattleReportAddId(builder, fbs.CreateUUID(builder, 1, 2))
+		fbs.BattleReportAddProtocol(builder, protocolVector)
+		return fbs.BattleReportEnd(builder)
+	})
+
+	_, err := PayloadToBattleReport(payload)
+	if err == nil {
+		t.Fatal("expected overflow error")
+	}
+	if !strings.Contains(err.Error(), "overflows int") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToBattleReportOverflowUint(t *testing.T) {
+	t.Parallel()
+
+	if strconv.IntSize == 64 {
+		t.Skip("uint overflow from uint64 is not possible on 64-bit runtime")
+	}
+
+	maxUint := uint64(^uint(0))
+	overflowValue := maxUint + 1
+	payload := buildBattleReportPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		fbs.BattleReportStart(builder)
+		fbs.BattleReportAddId(builder, fbs.CreateUUID(builder, 1, 2))
+		fbs.BattleReportAddPlanet(builder, overflowValue)
+		return fbs.BattleReportEnd(builder)
+	})
+
+	_, err := PayloadToBattleReport(payload)
+	if err == nil {
+		t.Fatal("expected overflow error")
+	}
+	if !strings.Contains(err.Error(), "overflows uint") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestBattleReportToPayloadDeterministicMapEncoding(t *testing.T) {
+	t.Parallel()
+
+	report := sampleBattleReport()
+
+	firstPayload, err := BattleReportToPayload(report)
+	if err != nil {
+		t.Fatalf("encode battle report payload: %v", err)
+	}
+
+	for i := 0; i < 20; i++ {
+		nextPayload, nextErr := BattleReportToPayload(report)
+		if nextErr != nil {
+			t.Fatalf("encode battle report payload #%d: %v", i+2, nextErr)
+		}
+		if !bytes.Equal(firstPayload, nextPayload) {
+			t.Fatalf("payload differs between runs at iteration %d", i+2)
+		}
+	}
+}
+
+func sampleBattleReport() *model.BattleReport {
+	return &model.BattleReport{
+		ID:         uuid.MustParse("44444444-4444-4444-4444-444444444444"),
+		Planet:     12,
+		PlanetName: "Nexus",
+		Races: map[int]uuid.UUID{
+			2: uuid.MustParse("55555555-5555-5555-5555-555555555555"),
+			1: uuid.MustParse("66666666-6666-6666-6666-666666666666"),
+		},
+		Ships: map[int]model.BattleReportGroup{
+			3: {
+				InBattle:     true,
+				Number:       20,
+				NumberLeft:   7,
+				LoadQuantity: model.Float(3.5),
+				Tech:         map[string]model.Float{"WEAPONS": model.Float(2.0), "DRIVE": model.Float(1.5)},
+				Race:         "Terrans",
+				ClassName:    "Frigate",
+				LoadType:     "MAT",
+			},
+			1: {
+				InBattle:     false,
+				Number:       15,
+				NumberLeft:   15,
+				LoadQuantity: model.Float(0.0),
+				Tech:         map[string]model.Float{"CARGO": model.Float(1.25), "SHIELDS": model.Float(1.75)},
+				Race:         "Martians",
+				ClassName:    "Destroyer",
+				LoadType:     "CAP",
+			},
+		},
+		Protocol: []model.BattleActionReport{
+			{Attacker: 1, AttackerShipClass: 3, Defender: 2, DefenderShipClass: 1, Destroyed: true},
+			{Attacker: 2, AttackerShipClass: 1, Defender: 1, DefenderShipClass: 3, Destroyed: false},
+		},
+	}
+}
+
+func battleReportWireClone(t *testing.T, source *model.BattleReport) *model.BattleReport {
+	t.Helper()
+
+	data, err := source.MarshalBinary()
+	if err != nil {
+		t.Fatalf("marshal source battle report: %v", err)
+	}
+
+	result := new(model.BattleReport)
+	if err := result.UnmarshalBinary(data); err != nil {
+		t.Fatalf("unmarshal source battle report clone: %v", err)
+	}
+
+	return result
+}
+
+func buildBattleReportPayload(build func(*flatbuffers.Builder) flatbuffers.UOffsetT) []byte {
+	builder := flatbuffers.NewBuilder(256)
+	offset := build(builder)
+	fbs.FinishBattleReportBuffer(builder, offset)
+	return builder.FinishedBytes()
+}

pkg/transcoder/go.mod

@@ -0,0 +1,8 @@
+module galaxy/transcoder
+
+go 1.26.0
+
+require (
+	github.com/google/flatbuffers v25.12.19+incompatible
+	github.com/google/uuid v1.6.0
+)

pkg/transcoder/go.sum

@@ -0,0 +1,2 @@
+github.com/google/flatbuffers v25.12.19+incompatible h1:haMV2JRRJCe1998HeW/p0X9UaMTK6SDo0ffLn2+DbLs=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=

pkg/transcoder/order.go

@@ -0,0 +1,899 @@
+package transcoder
+
+import (
+	"errors"
+	"fmt"
+
+	model "galaxy/model/order"
+	fbs "galaxy/schema/fbs/order"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+// OrderToPayload converts model.Order from the internal representation to
+// FlatBuffers bytes that can be sent over network transports.
+//
+// The function returns an error when the input contains unsupported command
+// types or values that cannot be represented by the current FlatBuffers schema.
+func OrderToPayload(o *model.Order) ([]byte, error) {
+	if o == nil {
+		return nil, errors.New("encode order payload: order is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(1024)
+	commandOffsets := make([]flatbuffers.UOffsetT, len(o.Commands))
+
+	for i := range o.Commands {
+		encoded, err := encodeOrderCommand(builder, o.Commands[i], i)
+		if err != nil {
+			return nil, err
+		}
+
+		cmdID := builder.CreateString(encoded.cmdID)
+
+		fbs.CommandItemStart(builder)
+		fbs.CommandItemAddCmdId(builder, cmdID)
+		if encoded.cmdApplied != nil {
+			fbs.CommandItemAddCmdApplied(builder, *encoded.cmdApplied)
+		}
+		if encoded.cmdErrCode != nil {
+			fbs.CommandItemAddCmdErrorCode(builder, int64(*encoded.cmdErrCode))
+		}
+		fbs.CommandItemAddPayloadType(builder, encoded.payloadType)
+		fbs.CommandItemAddPayload(builder, encoded.payloadOffset)
+		commandOffsets[i] = fbs.CommandItemEnd(builder)
+	}
+
+	var commandsVector flatbuffers.UOffsetT
+	if len(commandOffsets) > 0 {
+		fbs.OrderStartCommandsVector(builder, len(commandOffsets))
+		for i := len(commandOffsets) - 1; i >= 0; i-- {
+			builder.PrependUOffsetT(commandOffsets[i])
+		}
+		commandsVector = builder.EndVector(len(commandOffsets))
+	}
+
+	fbs.OrderStart(builder)
+	fbs.OrderAddUpdatedAt(builder, int64(o.UpdatedAt))
+	if len(commandOffsets) > 0 {
+		fbs.OrderAddCommands(builder, commandsVector)
+	}
+	orderOffset := fbs.OrderEnd(builder)
+	fbs.FinishOrderBuffer(builder, orderOffset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToOrder converts FlatBuffers payload bytes into model.Order.
+//
+// The function validates payload structure, command payload type, enum values,
+// and integer conversions. Malformed payloads are returned as errors.
+func PayloadToOrder(data []byte) (result *model.Order, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode order payload: data is empty")
+	}
+
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			result = nil
+			err = fmt.Errorf("decode order payload: panic recovered: %v", recovered)
+		}
+	}()
+
+	flatOrder := fbs.GetRootAsOrder(data, 0)
+	updatedAt, err := int64ToInt(flatOrder.UpdatedAt(), "updated_at")
+	if err != nil {
+		return nil, fmt.Errorf("decode order payload: %w", err)
+	}
+
+	result = &model.Order{UpdatedAt: updatedAt}
+	commandsLen := flatOrder.CommandsLength()
+	if commandsLen > 0 {
+		result.Commands = make([]model.DecodableCommand, commandsLen)
+	}
+
+	flatCommand := new(fbs.CommandItem)
+	for i := 0; i < commandsLen; i++ {
+		if !flatOrder.Commands(flatCommand, i) {
+			return nil, fmt.Errorf("decode order command %d: command item is missing", i)
+		}
+
+		command, err := decodeOrderCommand(flatCommand, i)
+		if err != nil {
+			return nil, err
+		}
+		result.Commands[i] = command
+	}
+
+	return result, nil
+}
+
+type encodedCommand struct {
+	cmdID         string
+	cmdApplied    *bool
+	cmdErrCode    *int
+	payloadType   fbs.CommandPayload
+	payloadOffset flatbuffers.UOffsetT
+}
+
+func encodeOrderCommand(builder *flatbuffers.Builder, command model.DecodableCommand, index int) (encodedCommand, error) {
+	if command == nil {
+		return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil", index)
+	}
+
+	switch cmd := command.(type) {
+	case *model.CommandRaceQuit:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		fbs.CommandRaceQuitStart(builder)
+		payload := fbs.CommandRaceQuitEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandRaceQuit, payload), nil
+	case *model.CommandRaceVote:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		acceptor := builder.CreateString(cmd.Acceptor)
+		fbs.CommandRaceVoteStart(builder)
+		fbs.CommandRaceVoteAddAcceptor(builder, acceptor)
+		payload := fbs.CommandRaceVoteEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandRaceVote, payload), nil
+	case *model.CommandRaceRelation:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		relation, err := relationToFBS(cmd.Relation)
+		if err != nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: %w", index, err)
+		}
+		acceptor := builder.CreateString(cmd.Acceptor)
+		fbs.CommandRaceRelationStart(builder)
+		fbs.CommandRaceRelationAddAcceptor(builder, acceptor)
+		fbs.CommandRaceRelationAddRelation(builder, relation)
+		payload := fbs.CommandRaceRelationEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandRaceRelation, payload), nil
+	case *model.CommandShipClassCreate:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		name := builder.CreateString(cmd.Name)
+		fbs.CommandShipClassCreateStart(builder)
+		fbs.CommandShipClassCreateAddName(builder, name)
+		fbs.CommandShipClassCreateAddDrive(builder, cmd.Drive)
+		fbs.CommandShipClassCreateAddArmament(builder, int64(cmd.Armament))
+		fbs.CommandShipClassCreateAddWeapons(builder, cmd.Weapons)
+		fbs.CommandShipClassCreateAddShields(builder, cmd.Shields)
+		fbs.CommandShipClassCreateAddCargo(builder, cmd.Cargo)
+		payload := fbs.CommandShipClassCreateEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipClassCreate, payload), nil
+	case *model.CommandShipClassMerge:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		name := builder.CreateString(cmd.Name)
+		target := builder.CreateString(cmd.Target)
+		fbs.CommandShipClassMergeStart(builder)
+		fbs.CommandShipClassMergeAddName(builder, name)
+		fbs.CommandShipClassMergeAddTarget(builder, target)
+		payload := fbs.CommandShipClassMergeEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipClassMerge, payload), nil
+	case *model.CommandShipClassRemove:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		name := builder.CreateString(cmd.Name)
+		fbs.CommandShipClassRemoveStart(builder)
+		fbs.CommandShipClassRemoveAddName(builder, name)
+		payload := fbs.CommandShipClassRemoveEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipClassRemove, payload), nil
+	case *model.CommandShipGroupBreak:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		id := builder.CreateString(cmd.ID)
+		newID := builder.CreateString(cmd.NewID)
+		fbs.CommandShipGroupBreakStart(builder)
+		fbs.CommandShipGroupBreakAddId(builder, id)
+		fbs.CommandShipGroupBreakAddNewId(builder, newID)
+		fbs.CommandShipGroupBreakAddQuantity(builder, int64(cmd.Quantity))
+		payload := fbs.CommandShipGroupBreakEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupBreak, payload), nil
+	case *model.CommandShipGroupLoad:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		cargo, err := shipGroupCargoToFBS(cmd.Cargo)
+		if err != nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: %w", index, err)
+		}
+		id := builder.CreateString(cmd.ID)
+		fbs.CommandShipGroupLoadStart(builder)
+		fbs.CommandShipGroupLoadAddId(builder, id)
+		fbs.CommandShipGroupLoadAddCargo(builder, cargo)
+		fbs.CommandShipGroupLoadAddQuantity(builder, cmd.Quantity)
+		payload := fbs.CommandShipGroupLoadEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupLoad, payload), nil
+	case *model.CommandShipGroupUnload:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		id := builder.CreateString(cmd.ID)
+		fbs.CommandShipGroupUnloadStart(builder)
+		fbs.CommandShipGroupUnloadAddId(builder, id)
+		fbs.CommandShipGroupUnloadAddQuantity(builder, cmd.Quantity)
+		payload := fbs.CommandShipGroupUnloadEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupUnload, payload), nil
+	case *model.CommandShipGroupSend:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		id := builder.CreateString(cmd.ID)
+		fbs.CommandShipGroupSendStart(builder)
+		fbs.CommandShipGroupSendAddId(builder, id)
+		fbs.CommandShipGroupSendAddDestination(builder, int64(cmd.Destination))
+		payload := fbs.CommandShipGroupSendEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupSend, payload), nil
+	case *model.CommandShipGroupUpgrade:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		tech, err := shipGroupUpgradeTechToFBS(cmd.Tech)
+		if err != nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: %w", index, err)
+		}
+		id := builder.CreateString(cmd.ID)
+		fbs.CommandShipGroupUpgradeStart(builder)
+		fbs.CommandShipGroupUpgradeAddId(builder, id)
+		fbs.CommandShipGroupUpgradeAddTech(builder, tech)
+		fbs.CommandShipGroupUpgradeAddLevel(builder, cmd.Level)
+		payload := fbs.CommandShipGroupUpgradeEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupUpgrade, payload), nil
+	case *model.CommandShipGroupMerge:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		fbs.CommandShipGroupMergeStart(builder)
+		payload := fbs.CommandShipGroupMergeEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupMerge, payload), nil
+	case *model.CommandShipGroupDismantle:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		id := builder.CreateString(cmd.ID)
+		fbs.CommandShipGroupDismantleStart(builder)
+		fbs.CommandShipGroupDismantleAddId(builder, id)
+		payload := fbs.CommandShipGroupDismantleEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupDismantle, payload), nil
+	case *model.CommandShipGroupTransfer:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		id := builder.CreateString(cmd.ID)
+		acceptor := builder.CreateString(cmd.Acceptor)
+		fbs.CommandShipGroupTransferStart(builder)
+		fbs.CommandShipGroupTransferAddId(builder, id)
+		fbs.CommandShipGroupTransferAddAcceptor(builder, acceptor)
+		payload := fbs.CommandShipGroupTransferEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupTransfer, payload), nil
+	case *model.CommandShipGroupJoinFleet:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		id := builder.CreateString(cmd.ID)
+		name := builder.CreateString(cmd.Name)
+		fbs.CommandShipGroupJoinFleetStart(builder)
+		fbs.CommandShipGroupJoinFleetAddId(builder, id)
+		fbs.CommandShipGroupJoinFleetAddName(builder, name)
+		payload := fbs.CommandShipGroupJoinFleetEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandShipGroupJoinFleet, payload), nil
+	case *model.CommandFleetMerge:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		name := builder.CreateString(cmd.Name)
+		target := builder.CreateString(cmd.Target)
+		fbs.CommandFleetMergeStart(builder)
+		fbs.CommandFleetMergeAddName(builder, name)
+		fbs.CommandFleetMergeAddTarget(builder, target)
+		payload := fbs.CommandFleetMergeEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandFleetMerge, payload), nil
+	case *model.CommandFleetSend:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		name := builder.CreateString(cmd.Name)
+		fbs.CommandFleetSendStart(builder)
+		fbs.CommandFleetSendAddName(builder, name)
+		fbs.CommandFleetSendAddDestination(builder, int64(cmd.Destination))
+		payload := fbs.CommandFleetSendEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandFleetSend, payload), nil
+	case *model.CommandScienceCreate:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		name := builder.CreateString(cmd.Name)
+		fbs.CommandScienceCreateStart(builder)
+		fbs.CommandScienceCreateAddName(builder, name)
+		fbs.CommandScienceCreateAddDrive(builder, cmd.Drive)
+		fbs.CommandScienceCreateAddWeapons(builder, cmd.Weapons)
+		fbs.CommandScienceCreateAddShields(builder, cmd.Shields)
+		fbs.CommandScienceCreateAddCargo(builder, cmd.Cargo)
+		payload := fbs.CommandScienceCreateEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandScienceCreate, payload), nil
+	case *model.CommandScienceRemove:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		name := builder.CreateString(cmd.Name)
+		fbs.CommandScienceRemoveStart(builder)
+		fbs.CommandScienceRemoveAddName(builder, name)
+		payload := fbs.CommandScienceRemoveEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandScienceRemove, payload), nil
+	case *model.CommandPlanetRename:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		name := builder.CreateString(cmd.Name)
+		fbs.CommandPlanetRenameStart(builder)
+		fbs.CommandPlanetRenameAddNumber(builder, int64(cmd.Number))
+		fbs.CommandPlanetRenameAddName(builder, name)
+		payload := fbs.CommandPlanetRenameEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandPlanetRename, payload), nil
+	case *model.CommandPlanetProduce:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		production, err := planetProductionToFBS(cmd.Production)
+		if err != nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: %w", index, err)
+		}
+		subject := builder.CreateString(cmd.Subject)
+		fbs.CommandPlanetProduceStart(builder)
+		fbs.CommandPlanetProduceAddNumber(builder, int64(cmd.Number))
+		fbs.CommandPlanetProduceAddProduction(builder, production)
+		fbs.CommandPlanetProduceAddSubject(builder, subject)
+		payload := fbs.CommandPlanetProduceEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandPlanetProduce, payload), nil
+	case *model.CommandPlanetRouteSet:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		loadType, err := planetRouteLoadTypeToFBS(cmd.LoadType)
+		if err != nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: %w", index, err)
+		}
+		fbs.CommandPlanetRouteSetStart(builder)
+		fbs.CommandPlanetRouteSetAddOrigin(builder, int64(cmd.Origin))
+		fbs.CommandPlanetRouteSetAddDestination(builder, int64(cmd.Destination))
+		fbs.CommandPlanetRouteSetAddLoadType(builder, loadType)
+		payload := fbs.CommandPlanetRouteSetEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandPlanetRouteSet, payload), nil
+	case *model.CommandPlanetRouteRemove:
+		if cmd == nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: command is nil %T", index, command)
+		}
+		loadType, err := planetRouteLoadTypeToFBS(cmd.LoadType)
+		if err != nil {
+			return encodedCommand{}, fmt.Errorf("encode order command %d: %w", index, err)
+		}
+		fbs.CommandPlanetRouteRemoveStart(builder)
+		fbs.CommandPlanetRouteRemoveAddOrigin(builder, int64(cmd.Origin))
+		fbs.CommandPlanetRouteRemoveAddLoadType(builder, loadType)
+		payload := fbs.CommandPlanetRouteRemoveEnd(builder)
+		return encodedCommandFromMeta(cmd.CommandMeta, fbs.CommandPayloadCommandPlanetRouteRemove, payload), nil
+	default:
+		return encodedCommand{}, fmt.Errorf("encode order command %d: unsupported command type %T", index, command)
+	}
+}
+
+func encodedCommandFromMeta(meta model.CommandMeta, payloadType fbs.CommandPayload, payloadOffset flatbuffers.UOffsetT) encodedCommand {
+	return encodedCommand{
+		cmdID:         meta.CmdID,
+		cmdApplied:    cloneBoolPointer(meta.CmdApplied),
+		cmdErrCode:    cloneIntPointer(meta.CmdErrCode),
+		payloadType:   payloadType,
+		payloadOffset: payloadOffset,
+	}
+}
+
+func decodeOrderCommand(flatCommand *fbs.CommandItem, index int) (model.DecodableCommand, error) {
+	commandMeta := model.CommandMeta{
+		CmdID:      string(flatCommand.CmdId()),
+		CmdApplied: cloneBoolPointer(flatCommand.CmdApplied()),
+	}
+
+	if cmdErrCode := flatCommand.CmdErrorCode(); cmdErrCode != nil {
+		decodedCmdErrCode, err := int64ToInt(*cmdErrCode, "cmd_error_code")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		commandMeta.CmdErrCode = &decodedCmdErrCode
+	}
+
+	payloadType := flatCommand.PayloadType()
+	if payloadType == fbs.CommandPayloadNONE {
+		return nil, fmt.Errorf("decode order command %d: payload type is NONE", index)
+	}
+
+	payload := new(flatbuffers.Table)
+	if !flatCommand.Payload(payload) {
+		return nil, fmt.Errorf("decode order command %d: payload is missing", index)
+	}
+
+	switch payloadType {
+	case fbs.CommandPayloadCommandRaceQuit:
+		commandMeta.CmdType = model.CommandTypeRaceQuit
+		return &model.CommandRaceQuit{CommandMeta: commandMeta}, nil
+	case fbs.CommandPayloadCommandRaceVote:
+		commandMeta.CmdType = model.CommandTypeRaceVote
+		commandPayload := new(fbs.CommandRaceVote)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandRaceVote{
+			CommandMeta: commandMeta,
+			Acceptor:    string(commandPayload.Acceptor()),
+		}, nil
+	case fbs.CommandPayloadCommandRaceRelation:
+		commandPayload := new(fbs.CommandRaceRelation)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+
+		relation, err := relationFromFBS(commandPayload.Relation())
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+
+		commandMeta.CmdType = model.CommandTypeRaceRelation
+		return &model.CommandRaceRelation{
+			CommandMeta: commandMeta,
+			Acceptor:    string(commandPayload.Acceptor()),
+			Relation:    relation,
+		}, nil
+	case fbs.CommandPayloadCommandShipClassCreate:
+		commandMeta.CmdType = model.CommandTypeShipClassCreate
+		commandPayload := new(fbs.CommandShipClassCreate)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		armament, err := int64ToInt(commandPayload.Armament(), "armament")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		return &model.CommandShipClassCreate{
+			CommandMeta: commandMeta,
+			Name:        string(commandPayload.Name()),
+			Drive:       commandPayload.Drive(),
+			Armament:    armament,
+			Weapons:     commandPayload.Weapons(),
+			Shields:     commandPayload.Shields(),
+			Cargo:       commandPayload.Cargo(),
+		}, nil
+	case fbs.CommandPayloadCommandShipClassMerge:
+		commandMeta.CmdType = model.CommandTypeShipClassMerge
+		commandPayload := new(fbs.CommandShipClassMerge)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandShipClassMerge{
+			CommandMeta: commandMeta,
+			Name:        string(commandPayload.Name()),
+			Target:      string(commandPayload.Target()),
+		}, nil
+	case fbs.CommandPayloadCommandShipClassRemove:
+		commandMeta.CmdType = model.CommandTypeShipClassRemove
+		commandPayload := new(fbs.CommandShipClassRemove)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandShipClassRemove{
+			CommandMeta: commandMeta,
+			Name:        string(commandPayload.Name()),
+		}, nil
+	case fbs.CommandPayloadCommandShipGroupBreak:
+		commandMeta.CmdType = model.CommandTypeShipGroupBreak
+		commandPayload := new(fbs.CommandShipGroupBreak)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		quantity, err := int64ToInt(commandPayload.Quantity(), "quantity")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		return &model.CommandShipGroupBreak{
+			CommandMeta: commandMeta,
+			ID:          string(commandPayload.Id()),
+			NewID:       string(commandPayload.NewId()),
+			Quantity:    quantity,
+		}, nil
+	case fbs.CommandPayloadCommandShipGroupLoad:
+		commandPayload := new(fbs.CommandShipGroupLoad)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+
+		cargo, err := shipGroupCargoFromFBS(commandPayload.Cargo())
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+
+		commandMeta.CmdType = model.CommandTypeShipGroupLoad
+		return &model.CommandShipGroupLoad{
+			CommandMeta: commandMeta,
+			ID:          string(commandPayload.Id()),
+			Cargo:       cargo,
+			Quantity:    commandPayload.Quantity(),
+		}, nil
+	case fbs.CommandPayloadCommandShipGroupUnload:
+		commandMeta.CmdType = model.CommandTypeShipGroupUnload
+		commandPayload := new(fbs.CommandShipGroupUnload)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandShipGroupUnload{
+			CommandMeta: commandMeta,
+			ID:          string(commandPayload.Id()),
+			Quantity:    commandPayload.Quantity(),
+		}, nil
+	case fbs.CommandPayloadCommandShipGroupSend:
+		commandMeta.CmdType = model.CommandTypeShipGroupSend
+		commandPayload := new(fbs.CommandShipGroupSend)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		destination, err := int64ToInt(commandPayload.Destination(), "destination")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		return &model.CommandShipGroupSend{
+			CommandMeta: commandMeta,
+			ID:          string(commandPayload.Id()),
+			Destination: destination,
+		}, nil
+	case fbs.CommandPayloadCommandShipGroupUpgrade:
+		commandPayload := new(fbs.CommandShipGroupUpgrade)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+
+		tech, err := shipGroupUpgradeTechFromFBS(commandPayload.Tech())
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+
+		commandMeta.CmdType = model.CommandTypeShipGroupUpgrade
+		return &model.CommandShipGroupUpgrade{
+			CommandMeta: commandMeta,
+			ID:          string(commandPayload.Id()),
+			Tech:        tech,
+			Level:       commandPayload.Level(),
+		}, nil
+	case fbs.CommandPayloadCommandShipGroupMerge:
+		commandMeta.CmdType = model.CommandTypeShipGroupMerge
+		return &model.CommandShipGroupMerge{CommandMeta: commandMeta}, nil
+	case fbs.CommandPayloadCommandShipGroupDismantle:
+		commandMeta.CmdType = model.CommandTypeShipGroupDismantle
+		commandPayload := new(fbs.CommandShipGroupDismantle)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandShipGroupDismantle{
+			CommandMeta: commandMeta,
+			ID:          string(commandPayload.Id()),
+		}, nil
+	case fbs.CommandPayloadCommandShipGroupTransfer:
+		commandMeta.CmdType = model.CommandTypeShipGroupTransfer
+		commandPayload := new(fbs.CommandShipGroupTransfer)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandShipGroupTransfer{
+			CommandMeta: commandMeta,
+			ID:          string(commandPayload.Id()),
+			Acceptor:    string(commandPayload.Acceptor()),
+		}, nil
+	case fbs.CommandPayloadCommandShipGroupJoinFleet:
+		commandMeta.CmdType = model.CommandTypeShipGroupJoinFleet
+		commandPayload := new(fbs.CommandShipGroupJoinFleet)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandShipGroupJoinFleet{
+			CommandMeta: commandMeta,
+			ID:          string(commandPayload.Id()),
+			Name:        string(commandPayload.Name()),
+		}, nil
+	case fbs.CommandPayloadCommandFleetMerge:
+		commandMeta.CmdType = model.CommandTypeFleetMerge
+		commandPayload := new(fbs.CommandFleetMerge)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandFleetMerge{
+			CommandMeta: commandMeta,
+			Name:        string(commandPayload.Name()),
+			Target:      string(commandPayload.Target()),
+		}, nil
+	case fbs.CommandPayloadCommandFleetSend:
+		commandMeta.CmdType = model.CommandTypeFleetSend
+		commandPayload := new(fbs.CommandFleetSend)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		destination, err := int64ToInt(commandPayload.Destination(), "destination")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		return &model.CommandFleetSend{
+			CommandMeta: commandMeta,
+			Name:        string(commandPayload.Name()),
+			Destination: destination,
+		}, nil
+	case fbs.CommandPayloadCommandScienceCreate:
+		commandMeta.CmdType = model.CommandTypeScienceCreate
+		commandPayload := new(fbs.CommandScienceCreate)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandScienceCreate{
+			CommandMeta: commandMeta,
+			Name:        string(commandPayload.Name()),
+			Drive:       commandPayload.Drive(),
+			Weapons:     commandPayload.Weapons(),
+			Shields:     commandPayload.Shields(),
+			Cargo:       commandPayload.Cargo(),
+		}, nil
+	case fbs.CommandPayloadCommandScienceRemove:
+		commandMeta.CmdType = model.CommandTypeScienceRemove
+		commandPayload := new(fbs.CommandScienceRemove)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		return &model.CommandScienceRemove{
+			CommandMeta: commandMeta,
+			Name:        string(commandPayload.Name()),
+		}, nil
+	case fbs.CommandPayloadCommandPlanetRename:
+		commandMeta.CmdType = model.CommandTypePlanetRename
+		commandPayload := new(fbs.CommandPlanetRename)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+		number, err := int64ToInt(commandPayload.Number(), "number")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		return &model.CommandPlanetRename{
+			CommandMeta: commandMeta,
+			Number:      number,
+			Name:        string(commandPayload.Name()),
+		}, nil
+	case fbs.CommandPayloadCommandPlanetProduce:
+		commandPayload := new(fbs.CommandPlanetProduce)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+
+		production, err := planetProductionFromFBS(commandPayload.Production())
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		number, err := int64ToInt(commandPayload.Number(), "number")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+
+		commandMeta.CmdType = model.CommandTypePlanetProduce
+		return &model.CommandPlanetProduce{
+			CommandMeta: commandMeta,
+			Number:      number,
+			Production:  production,
+			Subject:     string(commandPayload.Subject()),
+		}, nil
+	case fbs.CommandPayloadCommandPlanetRouteSet:
+		commandPayload := new(fbs.CommandPlanetRouteSet)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+
+		loadType, err := planetRouteLoadTypeFromFBS(commandPayload.LoadType())
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		origin, err := int64ToInt(commandPayload.Origin(), "origin")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		destination, err := int64ToInt(commandPayload.Destination(), "destination")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+
+		commandMeta.CmdType = model.CommandTypePlanetRouteSet
+		return &model.CommandPlanetRouteSet{
+			CommandMeta: commandMeta,
+			Origin:      origin,
+			Destination: destination,
+			LoadType:    loadType,
+		}, nil
+	case fbs.CommandPayloadCommandPlanetRouteRemove:
+		commandPayload := new(fbs.CommandPlanetRouteRemove)
+		commandPayload.Init(payload.Bytes, payload.Pos)
+
+		loadType, err := planetRouteLoadTypeFromFBS(commandPayload.LoadType())
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+		origin, err := int64ToInt(commandPayload.Origin(), "origin")
+		if err != nil {
+			return nil, fmt.Errorf("decode order command %d: %w", index, err)
+		}
+
+		commandMeta.CmdType = model.CommandTypePlanetRouteRemove
+		return &model.CommandPlanetRouteRemove{
+			CommandMeta: commandMeta,
+			Origin:      origin,
+			LoadType:    loadType,
+		}, nil
+	default:
+		return nil, fmt.Errorf("decode order command %d: unknown command payload type %d", index, payloadType)
+	}
+}
+
+func int64ToInt(value int64, field string) (int, error) {
+	maxInt := int64(int(^uint(0) >> 1))
+	minInt := -maxInt - 1
+
+	if value < minInt || value > maxInt {
+		return 0, fmt.Errorf("%s value %d overflows int", field, value)
+	}
+
+	return int(value), nil
+}
+
+func relationToFBS(value string) (fbs.Relation, error) {
+	switch value {
+	case "WAR":
+		return fbs.RelationWAR, nil
+	case "PEACE":
+		return fbs.RelationPEACE, nil
+	default:
+		return fbs.RelationUNKNOWN, fmt.Errorf("unsupported relation value %q", value)
+	}
+}
+
+func relationFromFBS(value fbs.Relation) (string, error) {
+	switch value {
+	case fbs.RelationWAR:
+		return "WAR", nil
+	case fbs.RelationPEACE:
+		return "PEACE", nil
+	case fbs.RelationUNKNOWN:
+		return "", errors.New("relation value UNKNOWN is not allowed")
+	default:
+		return "", fmt.Errorf("unsupported relation enum value %d", value)
+	}
+}
+
+func shipGroupCargoToFBS(value string) (fbs.ShipGroupCargo, error) {
+	switch value {
+	case "COL":
+		return fbs.ShipGroupCargoCOL, nil
+	case "MAT":
+		return fbs.ShipGroupCargoMAT, nil
+	case "CAP":
+		return fbs.ShipGroupCargoCAP, nil
+	default:
+		return fbs.ShipGroupCargoUNKNOWN, fmt.Errorf("unsupported ship group cargo value %q", value)
+	}
+}
+
+func shipGroupCargoFromFBS(value fbs.ShipGroupCargo) (string, error) {
+	switch value {
+	case fbs.ShipGroupCargoCOL:
+		return "COL", nil
+	case fbs.ShipGroupCargoMAT:
+		return "MAT", nil
+	case fbs.ShipGroupCargoCAP:
+		return "CAP", nil
+	case fbs.ShipGroupCargoUNKNOWN:
+		return "", errors.New("ship group cargo value UNKNOWN is not allowed")
+	default:
+		return "", fmt.Errorf("unsupported ship group cargo enum value %d", value)
+	}
+}
+
+func shipGroupUpgradeTechToFBS(value string) (fbs.ShipGroupUpgradeTech, error) {
+	switch value {
+	case "ALL":
+		return fbs.ShipGroupUpgradeTechALL, nil
+	case "DRIVE":
+		return fbs.ShipGroupUpgradeTechDRIVE, nil
+	case "WEAPONS":
+		return fbs.ShipGroupUpgradeTechWEAPONS, nil
+	case "SHIELDS":
+		return fbs.ShipGroupUpgradeTechSHIELDS, nil
+	case "CARGO":
+		return fbs.ShipGroupUpgradeTechCARGO, nil
+	default:
+		return fbs.ShipGroupUpgradeTechUNKNOWN, fmt.Errorf("unsupported ship group upgrade tech value %q", value)
+	}
+}
+
+func shipGroupUpgradeTechFromFBS(value fbs.ShipGroupUpgradeTech) (string, error) {
+	switch value {
+	case fbs.ShipGroupUpgradeTechALL:
+		return "ALL", nil
+	case fbs.ShipGroupUpgradeTechDRIVE:
+		return "DRIVE", nil
+	case fbs.ShipGroupUpgradeTechWEAPONS:
+		return "WEAPONS", nil
+	case fbs.ShipGroupUpgradeTechSHIELDS:
+		return "SHIELDS", nil
+	case fbs.ShipGroupUpgradeTechCARGO:
+		return "CARGO", nil
+	case fbs.ShipGroupUpgradeTechUNKNOWN:
+		return "", errors.New("ship group upgrade tech value UNKNOWN is not allowed")
+	default:
+		return "", fmt.Errorf("unsupported ship group upgrade tech enum value %d", value)
+	}
+}
+
+func planetProductionToFBS(value string) (fbs.PlanetProduction, error) {
+	switch value {
+	case "MAT":
+		return fbs.PlanetProductionMAT, nil
+	case "CAP":
+		return fbs.PlanetProductionCAP, nil
+	case "DRIVE":
+		return fbs.PlanetProductionDRIVE, nil
+	case "WEAPONS":
+		return fbs.PlanetProductionWEAPONS, nil
+	case "SHIELDS":
+		return fbs.PlanetProductionSHIELDS, nil
+	case "CARGO":
+		return fbs.PlanetProductionCARGO, nil
+	case "SCIENCE":
+		return fbs.PlanetProductionSCIENCE, nil
+	case "SHIP":
+		return fbs.PlanetProductionSHIP, nil
+	default:
+		return fbs.PlanetProductionUNKNOWN, fmt.Errorf("unsupported planet production value %q", value)
+	}
+}
+
+func planetProductionFromFBS(value fbs.PlanetProduction) (string, error) {
+	switch value {
+	case fbs.PlanetProductionMAT:
+		return "MAT", nil
+	case fbs.PlanetProductionCAP:
+		return "CAP", nil
+	case fbs.PlanetProductionDRIVE:
+		return "DRIVE", nil
+	case fbs.PlanetProductionWEAPONS:
+		return "WEAPONS", nil
+	case fbs.PlanetProductionSHIELDS:
+		return "SHIELDS", nil
+	case fbs.PlanetProductionCARGO:
+		return "CARGO", nil
+	case fbs.PlanetProductionSCIENCE:
+		return "SCIENCE", nil
+	case fbs.PlanetProductionSHIP:
+		return "SHIP", nil
+	case fbs.PlanetProductionUNKNOWN:
+		return "", errors.New("planet production value UNKNOWN is not allowed")
+	default:
+		return "", fmt.Errorf("unsupported planet production enum value %d", value)
+	}
+}
+
+func planetRouteLoadTypeToFBS(value string) (fbs.PlanetRouteLoadType, error) {
+	switch value {
+	case "MAT":
+		return fbs.PlanetRouteLoadTypeMAT, nil
+	case "CAP":
+		return fbs.PlanetRouteLoadTypeCAP, nil
+	case "COL":
+		return fbs.PlanetRouteLoadTypeCOL, nil
+	case "EMP":
+		return fbs.PlanetRouteLoadTypeEMP, nil
+	default:
+		return fbs.PlanetRouteLoadTypeUNKNOWN, fmt.Errorf("unsupported planet route load type value %q", value)
+	}
+}
+
+func planetRouteLoadTypeFromFBS(value fbs.PlanetRouteLoadType) (string, error) {
+	switch value {
+	case fbs.PlanetRouteLoadTypeMAT:
+		return "MAT", nil
+	case fbs.PlanetRouteLoadTypeCAP:
+		return "CAP", nil
+	case fbs.PlanetRouteLoadTypeCOL:
+		return "COL", nil
+	case fbs.PlanetRouteLoadTypeEMP:
+		return "EMP", nil
+	case fbs.PlanetRouteLoadTypeUNKNOWN:
+		return "", errors.New("planet route load type value UNKNOWN is not allowed")
+	default:
+		return "", fmt.Errorf("unsupported planet route load type enum value %d", value)
+	}
+}
+
+func cloneBoolPointer(value *bool) *bool {
+	if value == nil {
+		return nil
+	}
+
+	cloned := *value
+	return &cloned
+}
+
+func cloneIntPointer(value *int) *int {
+	if value == nil {
+		return nil
+	}
+
+	cloned := *value
+	return &cloned
+}

pkg/transcoder/order_test.go

@@ -0,0 +1,333 @@
+package transcoder
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	model "galaxy/model/order"
+	fbs "galaxy/schema/fbs/order"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+func TestOrderToPayloadAndPayloadToOrderRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	appliedTrue := true
+	appliedFalse := false
+	errZero := 0
+	errThree := 3
+	errSeven := 7
+
+	source := &model.Order{
+		UpdatedAt: 42,
+		Commands: []model.DecodableCommand{
+			&model.CommandRaceQuit{CommandMeta: commandMeta("cmd-01", model.CommandTypeRaceQuit, &appliedTrue, &errZero)},
+			&model.CommandRaceVote{CommandMeta: commandMeta("cmd-02", model.CommandTypeRaceVote, nil, nil), Acceptor: "race-a"},
+			&model.CommandRaceRelation{CommandMeta: commandMeta("cmd-03", model.CommandTypeRaceRelation, &appliedFalse, nil), Acceptor: "race-b", Relation: "WAR"},
+			&model.CommandShipClassCreate{CommandMeta: commandMeta("cmd-04", model.CommandTypeShipClassCreate, nil, &errThree), Name: "frigate", Drive: 1.5, Armament: 5, Weapons: 2.5, Shields: 3.5, Cargo: 4.5},
+			&model.CommandShipClassMerge{CommandMeta: commandMeta("cmd-05", model.CommandTypeShipClassMerge, nil, nil), Name: "alpha", Target: "beta"},
+			&model.CommandShipClassRemove{CommandMeta: commandMeta("cmd-06", model.CommandTypeShipClassRemove, nil, nil), Name: "obsolete"},
+			&model.CommandShipGroupBreak{CommandMeta: commandMeta("cmd-07", model.CommandTypeShipGroupBreak, nil, nil), ID: "group-1", NewID: "group-2", Quantity: 12},
+			&model.CommandShipGroupLoad{CommandMeta: commandMeta("cmd-08", model.CommandTypeShipGroupLoad, nil, nil), ID: "group-3", Cargo: "MAT", Quantity: 7.25},
+			&model.CommandShipGroupUnload{CommandMeta: commandMeta("cmd-09", model.CommandTypeShipGroupUnload, nil, nil), ID: "group-4", Quantity: 1.75},
+			&model.CommandShipGroupSend{CommandMeta: commandMeta("cmd-10", model.CommandTypeShipGroupSend, nil, nil), ID: "group-5", Destination: 19},
+			&model.CommandShipGroupUpgrade{CommandMeta: commandMeta("cmd-11", model.CommandTypeShipGroupUpgrade, nil, nil), ID: "group-6", Tech: "SHIELDS", Level: 2.0},
+			&model.CommandShipGroupMerge{CommandMeta: commandMeta("cmd-12", model.CommandTypeShipGroupMerge, nil, nil)},
+			&model.CommandShipGroupDismantle{CommandMeta: commandMeta("cmd-13", model.CommandTypeShipGroupDismantle, nil, nil), ID: "group-7"},
+			&model.CommandShipGroupTransfer{CommandMeta: commandMeta("cmd-14", model.CommandTypeShipGroupTransfer, nil, &errSeven), ID: "group-8", Acceptor: "race-c"},
+			&model.CommandShipGroupJoinFleet{CommandMeta: commandMeta("cmd-15", model.CommandTypeShipGroupJoinFleet, nil, nil), ID: "group-9", Name: "fleet-a"},
+			&model.CommandFleetMerge{CommandMeta: commandMeta("cmd-16", model.CommandTypeFleetMerge, nil, nil), Name: "fleet-b", Target: "fleet-c"},
+			&model.CommandFleetSend{CommandMeta: commandMeta("cmd-17", model.CommandTypeFleetSend, nil, nil), Name: "fleet-d", Destination: 31},
+			&model.CommandScienceCreate{CommandMeta: commandMeta("cmd-18", model.CommandTypeScienceCreate, nil, nil), Name: "science-a", Drive: 0.1, Weapons: 0.2, Shields: 0.3, Cargo: 0.4},
+			&model.CommandScienceRemove{CommandMeta: commandMeta("cmd-19", model.CommandTypeScienceRemove, nil, nil), Name: "science-b"},
+			&model.CommandPlanetRename{CommandMeta: commandMeta("cmd-20", model.CommandTypePlanetRename, nil, nil), Number: 7, Name: "new-name"},
+			&model.CommandPlanetProduce{CommandMeta: commandMeta("cmd-21", model.CommandTypePlanetProduce, nil, nil), Number: 8, Production: "SHIP", Subject: "frigate"},
+			&model.CommandPlanetRouteSet{CommandMeta: commandMeta("cmd-22", model.CommandTypePlanetRouteSet, nil, nil), Origin: 9, Destination: 10, LoadType: "EMP"},
+			&model.CommandPlanetRouteRemove{CommandMeta: commandMeta("cmd-23", model.CommandTypePlanetRouteRemove, nil, nil), Origin: 11, LoadType: "COL"},
+		},
+	}
+
+	payload, err := OrderToPayload(source)
+	if err != nil {
+		t.Fatalf("encode order payload: %v", err)
+	}
+
+	decoded, err := PayloadToOrder(payload)
+	if err != nil {
+		t.Fatalf("decode order payload: %v", err)
+	}
+
+	if !reflect.DeepEqual(source, decoded) {
+		t.Fatalf("round-trip mismatch\nsource: %#v\ndecoded:%#v", source, decoded)
+	}
+}
+
+func TestOrderToPayloadNilOrder(t *testing.T) {
+	t.Parallel()
+
+	_, err := OrderToPayload(nil)
+	if err == nil {
+		t.Fatal("expected error for nil order")
+	}
+}
+
+func TestOrderToPayloadUnsupportedCommandType(t *testing.T) {
+	t.Parallel()
+
+	source := &model.Order{
+		Commands: []model.DecodableCommand{unsupportedCommand{}},
+	}
+
+	_, err := OrderToPayload(source)
+	if err == nil {
+		t.Fatal("expected error for unsupported command type")
+	}
+	if !strings.Contains(err.Error(), "unsupported command type") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestOrderToPayloadTypedNilCommand(t *testing.T) {
+	t.Parallel()
+
+	var typedNil *model.CommandRaceQuit
+	source := &model.Order{
+		Commands: []model.DecodableCommand{typedNil},
+	}
+
+	_, err := OrderToPayload(source)
+	if err == nil {
+		t.Fatal("expected error for typed nil command")
+	}
+	if !strings.Contains(err.Error(), "command is nil") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestOrderToPayloadInvalidEnum(t *testing.T) {
+	t.Parallel()
+
+	source := &model.Order{
+		Commands: []model.DecodableCommand{
+			&model.CommandRaceRelation{
+				CommandMeta: commandMeta("cmd-1", model.CommandTypeRaceRelation, nil, nil),
+				Acceptor:    "race-a",
+				Relation:    "ALLY",
+			},
+		},
+	}
+
+	_, err := OrderToPayload(source)
+	if err == nil {
+		t.Fatal("expected error for invalid enum value")
+	}
+	if !strings.Contains(err.Error(), "unsupported relation value") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToOrderEmptyData(t *testing.T) {
+	t.Parallel()
+
+	_, err := PayloadToOrder(nil)
+	if err == nil {
+		t.Fatal("expected error for empty payload")
+	}
+}
+
+func TestPayloadToOrderGarbageDataDoesNotPanic(t *testing.T) {
+	t.Parallel()
+
+	_, err := PayloadToOrder([]byte{0x01, 0x02, 0x03})
+	if err == nil {
+		t.Fatal("expected error for malformed payload")
+	}
+}
+
+func TestPayloadToOrderUnknownPayloadType(t *testing.T) {
+	t.Parallel()
+
+	payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		fbs.CommandRaceQuitStart(builder)
+		commandPayload := fbs.CommandRaceQuitEnd(builder)
+		cmdID := builder.CreateString("cmd-1")
+
+		fbs.CommandItemStart(builder)
+		fbs.CommandItemAddCmdId(builder, cmdID)
+		fbs.CommandItemAddPayloadType(builder, fbs.CommandPayload(127))
+		fbs.CommandItemAddPayload(builder, commandPayload)
+		return fbs.CommandItemEnd(builder)
+	})
+
+	_, err := PayloadToOrder(payload)
+	if err == nil {
+		t.Fatal("expected error for unknown payload type")
+	}
+	if !strings.Contains(err.Error(), "unknown command payload type") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToOrderMissingPayload(t *testing.T) {
+	t.Parallel()
+
+	payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		cmdID := builder.CreateString("cmd-1")
+
+		fbs.CommandItemStart(builder)
+		fbs.CommandItemAddCmdId(builder, cmdID)
+		fbs.CommandItemAddPayloadType(builder, fbs.CommandPayloadCommandRaceQuit)
+		return fbs.CommandItemEnd(builder)
+	})
+
+	_, err := PayloadToOrder(payload)
+	if err == nil {
+		t.Fatal("expected error for missing payload")
+	}
+	if !strings.Contains(err.Error(), "payload is missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToOrderPayloadTypeNone(t *testing.T) {
+	t.Parallel()
+
+	payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		fbs.CommandRaceQuitStart(builder)
+		commandPayload := fbs.CommandRaceQuitEnd(builder)
+
+		cmdID := builder.CreateString("cmd-1")
+		fbs.CommandItemStart(builder)
+		fbs.CommandItemAddCmdId(builder, cmdID)
+		fbs.CommandItemAddPayload(builder, commandPayload)
+		return fbs.CommandItemEnd(builder)
+	})
+
+	_, err := PayloadToOrder(payload)
+	if err == nil {
+		t.Fatal("expected error for NONE payload type")
+	}
+	if !strings.Contains(err.Error(), "payload type is NONE") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToOrderUnknownEnum(t *testing.T) {
+	t.Parallel()
+
+	payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		acceptor := builder.CreateString("race-a")
+		fbs.CommandRaceRelationStart(builder)
+		fbs.CommandRaceRelationAddAcceptor(builder, acceptor)
+		fbs.CommandRaceRelationAddRelation(builder, fbs.RelationUNKNOWN)
+		commandPayload := fbs.CommandRaceRelationEnd(builder)
+
+		cmdID := builder.CreateString("cmd-1")
+		fbs.CommandItemStart(builder)
+		fbs.CommandItemAddCmdId(builder, cmdID)
+		fbs.CommandItemAddPayloadType(builder, fbs.CommandPayloadCommandRaceRelation)
+		fbs.CommandItemAddPayload(builder, commandPayload)
+		return fbs.CommandItemEnd(builder)
+	})
+
+	_, err := PayloadToOrder(payload)
+	if err == nil {
+		t.Fatal("expected error for UNKNOWN enum")
+	}
+	if !strings.Contains(err.Error(), "UNKNOWN") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToOrderOverflow(t *testing.T) {
+	t.Parallel()
+
+	if strconv.IntSize == 64 {
+		t.Skip("int overflow from int64 is not possible on 64-bit runtime")
+	}
+
+	maxInt := int(^uint(0) >> 1)
+	overflowValue := int64(maxInt) + 1
+	payload := buildSingleCommandOrderPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		name := builder.CreateString("planet-a")
+		fbs.CommandPlanetRenameStart(builder)
+		fbs.CommandPlanetRenameAddNumber(builder, overflowValue)
+		fbs.CommandPlanetRenameAddName(builder, name)
+		commandPayload := fbs.CommandPlanetRenameEnd(builder)
+
+		cmdID := builder.CreateString("cmd-1")
+		fbs.CommandItemStart(builder)
+		fbs.CommandItemAddCmdId(builder, cmdID)
+		fbs.CommandItemAddPayloadType(builder, fbs.CommandPayloadCommandPlanetRename)
+		fbs.CommandItemAddPayload(builder, commandPayload)
+		return fbs.CommandItemEnd(builder)
+	})
+
+	_, err := PayloadToOrder(payload)
+	if err == nil {
+		t.Fatal("expected overflow error")
+	}
+	if !strings.Contains(err.Error(), "overflows int") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestInt64ToInt(t *testing.T) {
+	t.Parallel()
+
+	value, err := int64ToInt(123, "field")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if value != 123 {
+		t.Fatalf("unexpected int value: %d", value)
+	}
+
+	if strconv.IntSize == 32 {
+		maxInt := int(^uint(0) >> 1)
+		_, err = int64ToInt(int64(maxInt)+1, "field")
+		if err == nil {
+			t.Fatal("expected overflow error")
+		}
+	}
+}
+
+type unsupportedCommand struct{}
+
+func (unsupportedCommand) CommandID() string {
+	return "unsupported"
+}
+
+func (unsupportedCommand) CommandType() model.CommandType {
+	return model.CommandType("unsupported")
+}
+
+func commandMeta(id string, cmdType model.CommandType, applied *bool, errCode *int) model.CommandMeta {
+	return model.CommandMeta{
+		CmdType:    cmdType,
+		CmdID:      id,
+		CmdApplied: applied,
+		CmdErrCode: errCode,
+	}
+}
+
+func buildSingleCommandOrderPayload(itemBuilder func(*flatbuffers.Builder) flatbuffers.UOffsetT) []byte {
+	builder := flatbuffers.NewBuilder(256)
+
+	itemOffset := itemBuilder(builder)
+
+	fbs.OrderStartCommandsVector(builder, 1)
+	builder.PrependUOffsetT(itemOffset)
+	commands := builder.EndVector(1)
+
+	fbs.OrderStart(builder)
+	fbs.OrderAddUpdatedAt(builder, 1)
+	fbs.OrderAddCommands(builder, commands)
+	orderOffset := fbs.OrderEnd(builder)
+	fbs.FinishOrderBuffer(builder, orderOffset)
+
+	return builder.FinishedBytes()
+}

pkg/transcoder/report_test.go

@@ -0,0 +1,355 @@
+package transcoder
+
+import (
+	"bytes"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	model "galaxy/model/report"
+	fbs "galaxy/schema/fbs/report"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+	"github.com/google/uuid"
+)
+
+func TestReportToPayloadAndPayloadToReportRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	source := sampleReport()
+
+	payload, err := ReportToPayload(source)
+	if err != nil {
+		t.Fatalf("encode report payload: %v", err)
+	}
+
+	decoded, err := PayloadToReport(payload)
+	if err != nil {
+		t.Fatalf("decode report payload: %v", err)
+	}
+
+	expected := reportWireClone(t, source)
+	if !reflect.DeepEqual(expected, decoded) {
+		t.Fatalf("round-trip mismatch\nexpected: %#v\ndecoded:  %#v", expected, decoded)
+	}
+}
+
+func TestReportToPayloadNilReport(t *testing.T) {
+	t.Parallel()
+
+	_, err := ReportToPayload(nil)
+	if err == nil {
+		t.Fatal("expected error for nil report")
+	}
+}
+
+func TestPayloadToReportEmptyData(t *testing.T) {
+	t.Parallel()
+
+	_, err := PayloadToReport(nil)
+	if err == nil {
+		t.Fatal("expected error for empty payload")
+	}
+}
+
+func TestPayloadToReportGarbageDataDoesNotPanic(t *testing.T) {
+	t.Parallel()
+
+	_, err := PayloadToReport([]byte{0x01, 0x02, 0x03})
+	if err == nil {
+		t.Fatal("expected error for malformed payload")
+	}
+}
+
+func TestPayloadToReportMissingRequiredLocalGroupID(t *testing.T) {
+	t.Parallel()
+
+	payload := buildReportPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		class := builder.CreateString("frigate")
+		state := builder.CreateString("orbit")
+
+		fbs.LocalGroupStart(builder)
+		fbs.LocalGroupAddClass(builder, class)
+		fbs.LocalGroupAddState(builder, state)
+		localGroup := fbs.LocalGroupEnd(builder)
+
+		fbs.ReportStartLocalGroupVector(builder, 1)
+		builder.PrependUOffsetT(localGroup)
+		localGroups := builder.EndVector(1)
+
+		fbs.ReportStart(builder)
+		fbs.ReportAddLocalGroup(builder, localGroups)
+		return fbs.ReportEnd(builder)
+	})
+
+	_, err := PayloadToReport(payload)
+	if err == nil {
+		t.Fatal("expected error for missing local group id")
+	}
+	if !strings.Contains(err.Error(), "id is missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToReportOverflow(t *testing.T) {
+	t.Parallel()
+
+	if strconv.IntSize == 64 {
+		t.Skip("uint overflow from uint64 is not possible on 64-bit runtime")
+	}
+
+	maxUint := uint64(^uint(0))
+	overflowValue := maxUint + 1
+	payload := buildReportPayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		fbs.ReportStart(builder)
+		fbs.ReportAddTurn(builder, overflowValue)
+		return fbs.ReportEnd(builder)
+	})
+
+	_, err := PayloadToReport(payload)
+	if err == nil {
+		t.Fatal("expected overflow error")
+	}
+	if !strings.Contains(err.Error(), "overflows uint") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestReportToPayloadDeterministicMapEncoding(t *testing.T) {
+	t.Parallel()
+
+	report := sampleReport()
+
+	firstPayload, err := ReportToPayload(report)
+	if err != nil {
+		t.Fatalf("encode report payload: %v", err)
+	}
+
+	for i := 0; i < 20; i++ {
+		nextPayload, nextErr := ReportToPayload(report)
+		if nextErr != nil {
+			t.Fatalf("encode report payload #%d: %v", i+2, nextErr)
+		}
+		if !bytes.Equal(firstPayload, nextPayload) {
+			t.Fatalf("payload differs between runs at iteration %d", i+2)
+		}
+	}
+}
+
+func TestReportToPayloadFloat32Quantization(t *testing.T) {
+	t.Parallel()
+
+	source := &model.Report{
+		Race:  "Terrans",
+		Votes: model.Float(0.123456789),
+		LocalScience: []model.Science{
+			{
+				Name:  "science-alpha",
+				Drive: model.Float(0.123456789),
+			},
+		},
+	}
+
+	payload, err := ReportToPayload(source)
+	if err != nil {
+		t.Fatalf("encode report payload: %v", err)
+	}
+
+	decoded, err := PayloadToReport(payload)
+	if err != nil {
+		t.Fatalf("decode report payload: %v", err)
+	}
+
+	wantVotes := model.Float(float64(float32(source.Votes.F())))
+	if decoded.Votes != wantVotes {
+		t.Fatalf("unexpected votes value: got=%v want=%v", decoded.Votes, wantVotes)
+	}
+
+	wantDrive := model.Float(float64(float32(source.LocalScience[0].Drive.F())))
+	if decoded.LocalScience[0].Drive != wantDrive {
+		t.Fatalf("unexpected drive value: got=%v want=%v", decoded.LocalScience[0].Drive, wantDrive)
+	}
+
+	if decoded.Votes == source.Votes {
+		t.Fatal("expected quantization for votes value")
+	}
+}
+
+func sampleReport() *model.Report {
+	originA := uint(11)
+	originB := uint(17)
+	rangeA := model.Float(6.5)
+	rangeB := model.Float(3.5)
+	fleetName := "Fleet-1"
+
+	return &model.Report{
+		Version:     2,
+		Turn:        7,
+		Width:       64,
+		Height:      48,
+		PlanetCount: 21,
+		Race:        "Terrans",
+		RaceID:      uuid.MustParse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"),
+		Votes:       model.Float(7.5),
+		VoteFor:     "Martians",
+		Player: []model.Player{
+			{
+				ID:         uuid.MustParse("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"),
+				Name:       "Terrans",
+				Drive:      model.Float(1.5),
+				Weapons:    model.Float(2.0),
+				Shields:    model.Float(2.5),
+				Cargo:      model.Float(3.0),
+				Population: model.Float(120.0),
+				Industry:   model.Float(90.0),
+				Planets:    5,
+				Relation:   "-",
+				Votes:      model.Float(7.5),
+				Extinct:    false,
+			},
+		},
+		LocalScience: []model.Science{
+			{Name: "fusion", Drive: model.Float(1.25), Weapons: model.Float(1.5), Shields: model.Float(1.75), Cargo: model.Float(2.0)},
+		},
+		OtherScience: []model.OtherScience{
+			{Race: "Martians", Science: model.Science{Name: "warp", Drive: model.Float(2.0), Weapons: model.Float(2.25), Shields: model.Float(2.5), Cargo: model.Float(2.75)}},
+		},
+		LocalShipClass: []model.ShipClass{
+			{Name: "frigate", Drive: model.Float(1.5), Armament: 4, Weapons: model.Float(2.0), Shields: model.Float(2.5), Cargo: model.Float(3.0), Mass: model.Float(9.5)},
+		},
+		OtherShipClass: []model.OthersShipClass{
+			{Race: "Martians", ShipClass: model.ShipClass{Name: "destroyer", Drive: model.Float(1.75), Armament: 6, Weapons: model.Float(2.25), Shields: model.Float(2.75), Cargo: model.Float(3.25), Mass: model.Float(10.5)}},
+		},
+		Battle: []uuid.UUID{
+			uuid.MustParse("11111111-1111-1111-1111-111111111111"),
+			uuid.MustParse("22222222-2222-2222-2222-222222222222"),
+		},
+		Bombing: []*model.Bombing{
+			{
+				PlanetOwnedID: uuid.MustParse("cccccccc-cccc-cccc-cccc-cccccccccccc"),
+				Number:        9,
+				Planet:        "Nova",
+				Owner:         "Terrans",
+				Attacker:      "Martians",
+				Production:    "SHIP",
+				Industry:      model.Float(10.5),
+				Population:    model.Float(8.5),
+				Colonists:     model.Float(7.5),
+				Capital:       model.Float(6.5),
+				Material:      model.Float(5.5),
+				AttackPower:   model.Float(4.5),
+				Wiped:         false,
+			},
+		},
+		IncomingGroup: []model.IncomingGroup{
+			{Origin: 1, Destination: 2, Distance: model.Float(10.0), Speed: model.Float(2.0), Mass: model.Float(20.0)},
+		},
+		LocalPlanet: []model.LocalPlanet{
+			{
+				UninhabitedPlanet: model.UninhabitedPlanet{
+					UnidentifiedPlanet: model.UnidentifiedPlanet{X: model.Float(1.0), Y: model.Float(2.0), Number: 3},
+					Size:               model.Float(50.0),
+					Name:               "Terra",
+					Resources:          model.Float(7.0),
+					Capital:            model.Float(8.0),
+					Material:           model.Float(9.0),
+				},
+				Industry:     model.Float(10.0),
+				Population:   model.Float(11.0),
+				Colonists:    model.Float(12.0),
+				Production:   "SHIP",
+				FreeIndustry: model.Float(13.0),
+			},
+		},
+		ShipProduction: []model.ShipProduction{
+			{Planet: 3, Class: "frigate", Cost: model.Float(4.0), ProdUsed: model.Float(2.0), Percent: model.Float(50.0), Free: model.Float(6.0)},
+		},
+		Route: []model.Route{
+			{Planet: 3, Route: map[uint]string{9: "MAT", 2: "CAP", 5: "EMP"}},
+		},
+		OtherPlanet: []model.OtherPlanet{
+			{
+				Owner: "Martians",
+				LocalPlanet: model.LocalPlanet{
+					UninhabitedPlanet: model.UninhabitedPlanet{
+						UnidentifiedPlanet: model.UnidentifiedPlanet{X: model.Float(4.0), Y: model.Float(5.0), Number: 6},
+						Size:               model.Float(40.0),
+						Name:               "Ares",
+						Resources:          model.Float(6.0),
+						Capital:            model.Float(7.0),
+						Material:           model.Float(8.0),
+					},
+					Industry:     model.Float(9.0),
+					Population:   model.Float(10.0),
+					Colonists:    model.Float(11.0),
+					Production:   "MAT",
+					FreeIndustry: model.Float(12.0),
+				},
+			},
+		},
+		UninhabitedPlanet: []model.UninhabitedPlanet{
+			{UnidentifiedPlanet: model.UnidentifiedPlanet{X: model.Float(6.0), Y: model.Float(7.0), Number: 8}, Size: model.Float(30.0), Name: "Nadir", Resources: model.Float(5.0), Capital: model.Float(4.0), Material: model.Float(3.0)},
+		},
+		UnidentifiedPlanet: []model.UnidentifiedPlanet{
+			{X: model.Float(8.0), Y: model.Float(9.0), Number: 10},
+		},
+		LocalFleet: []model.LocalFleet{
+			{Name: "Fleet-1", Groups: 2, Destination: 4, Origin: &originA, Range: &rangeA, Speed: model.Float(2.0), State: "moving"},
+		},
+		LocalGroup: []model.LocalGroup{
+			{
+				OtherGroup: model.OtherGroup{
+					Number:      1,
+					Class:       "frigate",
+					Tech:        map[string]model.Float{"WEAPONS": model.Float(2.0), "DRIVE": model.Float(1.5), "SHIELDS": model.Float(1.75)},
+					Cargo:       "MAT",
+					Load:        model.Float(4.0),
+					Destination: 4,
+					Origin:      &originB,
+					Range:       &rangeB,
+					Speed:       model.Float(2.5),
+					Mass:        model.Float(12.0),
+				},
+				ID:    uuid.MustParse("33333333-3333-3333-3333-333333333333"),
+				State: "in_orbit",
+				Fleet: &fleetName,
+			},
+		},
+		OtherGroup: []model.OtherGroup{
+			{Number: 2, Class: "scout", Tech: map[string]model.Float{"CARGO": model.Float(1.25), "DRIVE": model.Float(1.75)}, Cargo: "CAP", Load: model.Float(3.5), Destination: 5, Speed: model.Float(2.25), Mass: model.Float(8.5)},
+		},
+		UnidentifiedGroup: []model.UnidentifiedGroup{
+			{X: model.Float(10.0), Y: model.Float(11.0)},
+		},
+		OnPlanetGroupCache: map[uint][]int{
+			1: {2, 3},
+		},
+		InSpaceGroupRangeCache: map[int]map[uint]float64{
+			1: {4: 12.5},
+		},
+	}
+}
+
+func reportWireClone(t *testing.T, source *model.Report) *model.Report {
+	t.Helper()
+
+	data, err := source.MarshalBinary()
+	if err != nil {
+		t.Fatalf("marshal source report: %v", err)
+	}
+
+	result := new(model.Report)
+	if err := result.UnmarshalBinary(data); err != nil {
+		t.Fatalf("unmarshal source report clone: %v", err)
+	}
+
+	return result
+}
+
+func buildReportPayload(build func(*flatbuffers.Builder) flatbuffers.UOffsetT) []byte {
+	builder := flatbuffers.NewBuilder(256)
+	offset := build(builder)
+	fbs.FinishReportBuffer(builder, offset)
+	return builder.FinishedBytes()
+}