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