Add durable D&D combat turn artifacts
This commit is contained in:
259
internal/modules/dnd/codec/combatturns/codec.go
Normal file
259
internal/modules/dnd/codec/combatturns/codec.go
Normal file
@@ -0,0 +1,259 @@
|
||||
package combatturns
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"embed"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
|
||||
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
||||
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
||||
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
|
||||
)
|
||||
|
||||
const (
|
||||
SchemaID = "notarius.dnd.combat_turns"
|
||||
SchemaName = "notarius_dnd_combat_turns_v1"
|
||||
SchemaVersion = "v1"
|
||||
MediaType = "application/json"
|
||||
)
|
||||
|
||||
//go:embed assets/schemas/dnd_combat_turns.v1.json
|
||||
var schemaAssets embed.FS
|
||||
|
||||
var _ contracts.ArtifactCodec[dnd.CombatTurnList] = (*Codec)(nil)
|
||||
|
||||
type Codec struct{}
|
||||
|
||||
func New() *Codec { return &Codec{} }
|
||||
|
||||
func (c *Codec) Kind() contracts.ArtifactKind { return dnd.CombatTurnListKind }
|
||||
|
||||
func (c *Codec) Schema() contracts.ArtifactSchema {
|
||||
raw, err := schemaAssets.ReadFile("assets/schemas/dnd_combat_turns.v1.json")
|
||||
if err != nil {
|
||||
return contracts.ArtifactSchema{}
|
||||
}
|
||||
return contracts.ArtifactSchema{
|
||||
ID: SchemaID,
|
||||
Name: SchemaName,
|
||||
Version: SchemaVersion,
|
||||
JSONSchema: append([]byte(nil), raw...),
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Codec) MediaType() string { return MediaType }
|
||||
|
||||
func (c *Codec) Metadata(value dnd.CombatTurnList) map[string]any {
|
||||
return map[string]any{"combat_turn_count": len(value.CombatTurns)}
|
||||
}
|
||||
|
||||
func (c *Codec) Encode(value dnd.CombatTurnList) ([]byte, error) {
|
||||
if err := validate(value); err != nil {
|
||||
return nil, fmt.Errorf("encode dnd combat turn list: %w", err)
|
||||
}
|
||||
return c.EncodeCandidate(value)
|
||||
}
|
||||
|
||||
// EncodeCandidate provides the durable representation before typed validators
|
||||
// have approved a value.
|
||||
func (c *Codec) EncodeCandidate(value dnd.CombatTurnList) ([]byte, error) {
|
||||
content, err := json.Marshal(value)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("encode dnd combat turn list: %w", err)
|
||||
}
|
||||
return content, nil
|
||||
}
|
||||
|
||||
func (c *Codec) Decode(content []byte) (dnd.CombatTurnList, error) {
|
||||
value, err := c.DecodeCandidate(content)
|
||||
if err != nil {
|
||||
return dnd.CombatTurnList{}, err
|
||||
}
|
||||
if err := validate(value); err != nil {
|
||||
return dnd.CombatTurnList{}, fmt.Errorf("decode dnd combat turn list: %w", err)
|
||||
}
|
||||
return value, nil
|
||||
}
|
||||
|
||||
// DecodeCandidate reads one strict durable JSON value before semantic
|
||||
// validators have approved it. Nullable round and resolution fields are
|
||||
// decoded through raw values so a missing key is not confused with null.
|
||||
func (c *Codec) DecodeCandidate(content []byte) (dnd.CombatTurnList, error) {
|
||||
decoder := json.NewDecoder(bytes.NewReader(content))
|
||||
decoder.DisallowUnknownFields()
|
||||
var wire combatTurnListWire
|
||||
if err := decoder.Decode(&wire); err != nil {
|
||||
return dnd.CombatTurnList{}, fmt.Errorf("decode dnd combat turn list: %w", err)
|
||||
}
|
||||
var trailing any
|
||||
if err := decoder.Decode(&trailing); err != io.EOF {
|
||||
return dnd.CombatTurnList{}, fmt.Errorf("decode dnd combat turn list: multiple JSON values")
|
||||
}
|
||||
|
||||
value := dnd.CombatTurnList{CombatTurns: make([]dnd.CombatTurn, len(wire.CombatTurns))}
|
||||
if wire.CombatTurns == nil {
|
||||
value.CombatTurns = nil
|
||||
}
|
||||
for index, turn := range wire.CombatTurns {
|
||||
round, err := decodeNullableInt(turn.Round, fmt.Sprintf("combat_turns[%d].round", index))
|
||||
if err != nil {
|
||||
return dnd.CombatTurnList{}, err
|
||||
}
|
||||
actions := make([]dnd.CombatAction, len(turn.Actions))
|
||||
if turn.Actions == nil {
|
||||
actions = nil
|
||||
}
|
||||
for actionIndex, action := range turn.Actions {
|
||||
resolution, err := decodeNullableString(action.Resolution, fmt.Sprintf("combat_turns[%d].actions[%d].resolution", index, actionIndex))
|
||||
if err != nil {
|
||||
return dnd.CombatTurnList{}, err
|
||||
}
|
||||
actions[actionIndex] = dnd.CombatAction{
|
||||
Category: action.Category,
|
||||
Declaration: action.Declaration,
|
||||
Targets: action.Targets,
|
||||
Resolution: resolution,
|
||||
}
|
||||
}
|
||||
value.CombatTurns[index] = dnd.CombatTurn{
|
||||
Actor: turn.Actor,
|
||||
TurnKind: turn.TurnKind,
|
||||
Round: round,
|
||||
Actions: actions,
|
||||
Summary: turn.Summary,
|
||||
SourceRefs: turn.SourceRefs,
|
||||
}
|
||||
}
|
||||
return value, nil
|
||||
}
|
||||
|
||||
type combatTurnListWire struct {
|
||||
CombatTurns []combatTurnWire `json:"combat_turns"`
|
||||
}
|
||||
|
||||
type combatTurnWire struct {
|
||||
Actor string `json:"actor"`
|
||||
TurnKind dnd.CombatTurnKind `json:"turn_kind"`
|
||||
Round json.RawMessage `json:"round"`
|
||||
Actions []combatActionWire `json:"actions"`
|
||||
Summary string `json:"summary"`
|
||||
SourceRefs []source.SourceRef `json:"source_refs"`
|
||||
}
|
||||
|
||||
type combatActionWire struct {
|
||||
Category dnd.CombatActionCategory `json:"category"`
|
||||
Declaration string `json:"declaration"`
|
||||
Targets []string `json:"targets"`
|
||||
Resolution json.RawMessage `json:"resolution"`
|
||||
}
|
||||
|
||||
func decodeNullableInt(raw json.RawMessage, field string) (*int, error) {
|
||||
if len(raw) == 0 {
|
||||
return nil, fmt.Errorf("%s must be present", field)
|
||||
}
|
||||
trimmed := bytes.TrimSpace(raw)
|
||||
if bytes.Equal(trimmed, []byte("null")) {
|
||||
return nil, nil
|
||||
}
|
||||
var value int
|
||||
if err := json.Unmarshal(trimmed, &value); err != nil {
|
||||
return nil, fmt.Errorf("%s must be an integer or null: %w", field, err)
|
||||
}
|
||||
return &value, nil
|
||||
}
|
||||
|
||||
func decodeNullableString(raw json.RawMessage, field string) (*string, error) {
|
||||
if len(raw) == 0 {
|
||||
return nil, fmt.Errorf("%s must be present", field)
|
||||
}
|
||||
trimmed := bytes.TrimSpace(raw)
|
||||
if bytes.Equal(trimmed, []byte("null")) {
|
||||
return nil, nil
|
||||
}
|
||||
var value string
|
||||
if err := json.Unmarshal(trimmed, &value); err != nil {
|
||||
return nil, fmt.Errorf("%s must be a string or null: %w", field, err)
|
||||
}
|
||||
return &value, nil
|
||||
}
|
||||
|
||||
func validate(value dnd.CombatTurnList) error {
|
||||
if value.CombatTurns == nil {
|
||||
return fmt.Errorf("combat_turns must be present")
|
||||
}
|
||||
for index, turn := range value.CombatTurns {
|
||||
prefix := fmt.Sprintf("combat_turns[%d]", index)
|
||||
if strings.TrimSpace(turn.Actor) == "" {
|
||||
return fmt.Errorf("%s.actor must not be empty", prefix)
|
||||
}
|
||||
if !validTurnKind(turn.TurnKind) {
|
||||
return fmt.Errorf("%s.turn_kind must be supported", prefix)
|
||||
}
|
||||
if turn.Round != nil && *turn.Round <= 0 {
|
||||
return fmt.Errorf("%s.round must be positive or null", prefix)
|
||||
}
|
||||
if len(turn.Actions) == 0 {
|
||||
return fmt.Errorf("%s.actions must contain at least one action", prefix)
|
||||
}
|
||||
if strings.TrimSpace(turn.Summary) == "" {
|
||||
return fmt.Errorf("%s.summary must not be empty", prefix)
|
||||
}
|
||||
if len(turn.SourceRefs) == 0 {
|
||||
return fmt.Errorf("%s.source_refs must contain at least one reference", prefix)
|
||||
}
|
||||
for actionIndex, action := range turn.Actions {
|
||||
actionPrefix := fmt.Sprintf("%s.actions[%d]", prefix, actionIndex)
|
||||
if !validActionCategory(action.Category) {
|
||||
return fmt.Errorf("%s.category must be supported", actionPrefix)
|
||||
}
|
||||
if strings.TrimSpace(action.Declaration) == "" {
|
||||
return fmt.Errorf("%s.declaration must not be empty", actionPrefix)
|
||||
}
|
||||
if action.Targets == nil {
|
||||
return fmt.Errorf("%s.targets must be present", actionPrefix)
|
||||
}
|
||||
for targetIndex, target := range action.Targets {
|
||||
if strings.TrimSpace(target) == "" {
|
||||
return fmt.Errorf("%s.targets[%d] must not be empty", actionPrefix, targetIndex)
|
||||
}
|
||||
}
|
||||
if action.Resolution != nil && strings.TrimSpace(*action.Resolution) == "" {
|
||||
return fmt.Errorf("%s.resolution must not be empty or null", actionPrefix)
|
||||
}
|
||||
}
|
||||
for refIndex, ref := range turn.SourceRefs {
|
||||
refPrefix := fmt.Sprintf("%s.source_refs[%d]", prefix, refIndex)
|
||||
if strings.TrimSpace(ref.SourceID) == "" {
|
||||
return fmt.Errorf("%s.source_id must not be empty", refPrefix)
|
||||
}
|
||||
if ref.StartUnitID <= 0 {
|
||||
return fmt.Errorf("%s.start_unit_id must be positive", refPrefix)
|
||||
}
|
||||
if ref.EndUnitID <= 0 {
|
||||
return fmt.Errorf("%s.end_unit_id must be positive", refPrefix)
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func validTurnKind(value dnd.CombatTurnKind) bool {
|
||||
switch value {
|
||||
case dnd.CombatTurnKindTurn, dnd.CombatTurnKindReaction, dnd.CombatTurnKindLegendaryAction, dnd.CombatTurnKindLairAction, dnd.CombatTurnKindOther:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func validActionCategory(value dnd.CombatActionCategory) bool {
|
||||
switch value {
|
||||
case dnd.CombatActionCategoryAttack, dnd.CombatActionCategorySpell, dnd.CombatActionCategoryMovement, dnd.CombatActionCategoryItem, dnd.CombatActionCategoryAbilityCheck, dnd.CombatActionCategorySavingThrow, dnd.CombatActionCategoryCondition, dnd.CombatActionCategoryOther:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user