flatbuffers & transcoders

pkg/schema/fbs/order/CommandFleetMerge.go

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

pkg/schema/fbs/order/CommandFleetSend.go

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

pkg/schema/fbs/order/CommandItem.go

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

pkg/schema/fbs/order/CommandPayload.go

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

pkg/schema/fbs/order/CommandPlanetProduce.go

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

pkg/schema/fbs/order/CommandPlanetRename.go

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

pkg/schema/fbs/order/CommandPlanetRouteRemove.go

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

pkg/schema/fbs/order/CommandPlanetRouteSet.go

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

pkg/schema/fbs/order/CommandRaceQuit.go

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

pkg/schema/fbs/order/CommandRaceRelation.go

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

pkg/schema/fbs/order/CommandRaceVote.go

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

pkg/schema/fbs/order/CommandScienceCreate.go

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

pkg/schema/fbs/order/CommandScienceRemove.go

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

pkg/schema/fbs/order/CommandShipClassCreate.go

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

pkg/schema/fbs/order/CommandShipClassMerge.go

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

pkg/schema/fbs/order/CommandShipClassRemove.go

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

pkg/schema/fbs/order/CommandShipGroupBreak.go

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

pkg/schema/fbs/order/CommandShipGroupDismantle.go

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

pkg/schema/fbs/order/CommandShipGroupJoinFleet.go

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

pkg/schema/fbs/order/CommandShipGroupLoad.go

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

pkg/schema/fbs/order/CommandShipGroupMerge.go

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

pkg/schema/fbs/order/CommandShipGroupSend.go

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

pkg/schema/fbs/order/CommandShipGroupTransfer.go

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

pkg/schema/fbs/order/CommandShipGroupUnload.go

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

pkg/schema/fbs/order/CommandShipGroupUpgrade.go

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

pkg/schema/fbs/order/Order.go

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

pkg/schema/fbs/order/PlanetProduction.go

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

pkg/schema/fbs/order/PlanetRouteLoadType.go

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

pkg/schema/fbs/order/Relation.go

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

pkg/schema/fbs/order/ShipGroupCargo.go

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

pkg/schema/fbs/order/ShipGroupUpgradeTech.go

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