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