Add standalone D&D combat turn extraction

internal/modules/dnd/extract/combatturns/canonicalize.go

@@ -0,0 +1,156 @@
+package combatturns
+
+import (
+	"sort"
+
+	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
+	"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
+)
+
+func canonicalizeResponse(response *extractionResponse, doc *source.SourceDocument) {
+	if response == nil {
+		return
+	}
+	for index := range response.CombatTurns {
+		canonicalizeCombatTurn(&response.CombatTurns[index])
+	}
+	sort.SliceStable(response.CombatTurns, func(i, j int) bool {
+		left, leftOK := earliestSourcePosition(doc, response.CombatTurns[i])
+		right, rightOK := earliestSourcePosition(doc, response.CombatTurns[j])
+		if leftOK != rightOK {
+			return leftOK
+		}
+		if !leftOK {
+			return false
+		}
+		return left < right
+	})
+}
+
+func canonicalizeCombatTurn(turn *combatTurnResponse) {
+	if turn == nil {
+		return
+	}
+	sort.SliceStable(turn.SourceRefs, func(i, j int) bool {
+		left := turn.SourceRefs[i]
+		right := turn.SourceRefs[j]
+		if unitSortValue(left.StartUnitID) != unitSortValue(right.StartUnitID) {
+			return unitSortValue(left.StartUnitID) < unitSortValue(right.StartUnitID)
+		}
+		return unitSortValue(left.EndUnitID) < unitSortValue(right.EndUnitID)
+	})
+	turn.SourceRefs = dedupeSourceRefs(turn.SourceRefs)
+}
+
+func dedupeSourceRefs(refs []combatSourceRefResponse) []combatSourceRefResponse {
+	if len(refs) < 2 {
+		return refs
+	}
+	out := refs[:0]
+	var previous combatSourceRefResponse
+	for index, ref := range refs {
+		if index > 0 && sameSourceRef(previous, ref) {
+			continue
+		}
+		out = append(out, ref)
+		previous = ref
+	}
+	return out
+}
+
+func sameSourceRef(left combatSourceRefResponse, right combatSourceRefResponse) bool {
+	return left.StartUnitID.Int() == right.StartUnitID.Int() && left.EndUnitID.Int() == right.EndUnitID.Int()
+}
+
+func earliestSourcePosition(doc *source.SourceDocument, turn combatTurnResponse) (int, bool) {
+	if doc == nil {
+		return 0, false
+	}
+	earliest := 0
+	found := false
+	for _, ref := range turn.SourceRefs {
+		candidate := source.SourceRef{SourceID: doc.ID, StartUnitID: ref.StartUnitID.Int(), EndUnitID: ref.EndUnitID.Int()}
+		if err := source.ValidateRef(doc, candidate); err != nil {
+			continue
+		}
+		index, ok := source.UnitIndex(doc, candidate.StartUnitID)
+		if !ok || (found && index >= earliest) {
+			continue
+		}
+		earliest = index
+		found = true
+	}
+	return earliest, found
+}
+
+func unitSortValue(ref interface{ Int() int }) int {
+	value := ref.Int()
+	if value <= 0 {
+		return int(^uint(0) >> 1)
+	}
+	return value
+}
+
+func canonicalCombatTurnList(response extractionResponse, sourceID string) dnd.CombatTurnList {
+	turns := make([]dnd.CombatTurn, len(response.CombatTurns))
+	for index, turn := range response.CombatTurns {
+		turns[index] = dnd.CombatTurn{
+			Actor:      turn.Actor,
+			TurnKind:   dnd.CombatTurnKind(turn.TurnKind),
+			Round:      cloneIntPointer(turn.Round),
+			Actions:    canonicalActions(turn.Actions),
+			Summary:    turn.Summary,
+			SourceRefs: canonicalSourceRefs(turn.SourceRefs, sourceID),
+		}
+	}
+	if response.CombatTurns == nil {
+		turns = nil
+	}
+	return dnd.CombatTurnList{CombatTurns: turns}
+}
+
+func canonicalActions(actions []combatActionResponse) []dnd.CombatAction {
+	if actions == nil {
+		return nil
+	}
+	out := make([]dnd.CombatAction, len(actions))
+	for index, action := range actions {
+		out[index] = dnd.CombatAction{
+			Category:    dnd.CombatActionCategory(action.Category),
+			Declaration: action.Declaration,
+			Targets:     append([]string(nil), action.Targets...),
+			Resolution:  cloneStringPointer(action.Resolution),
+		}
+		if action.Targets != nil {
+			out[index].Targets = append([]string{}, action.Targets...)
+		}
+	}
+	return out
+}
+
+func canonicalSourceRefs(refs []combatSourceRefResponse, sourceID string) []source.SourceRef {
+	if refs == nil {
+		return nil
+	}
+	out := make([]source.SourceRef, len(refs))
+	for index, ref := range refs {
+		out[index] = source.SourceRef{SourceID: sourceID, StartUnitID: ref.StartUnitID.Int(), EndUnitID: ref.EndUnitID.Int()}
+	}
+	return out
+}
+
+func cloneIntPointer(value *int) *int {
+	if value == nil {
+		return nil
+	}
+	out := *value
+	return &out
+}
+
+func cloneStringPointer(value *string) *string {
+	if value == nil {
+		return nil
+	}
+	out := *value
+	return &out
+}