flatbuffers & transcoders

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