123 lines
3.0 KiB
Go
123 lines
3.0 KiB
Go
package npcs
|
|
|
|
import (
|
|
"sort"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
|
|
)
|
|
|
|
func canonicalizeResponse(response *extractionResponse, doc *source.SourceDocument) {
|
|
if response == nil {
|
|
return
|
|
}
|
|
for index := range response.NPCs {
|
|
canonicalizeNPC(&response.NPCs[index])
|
|
}
|
|
sort.SliceStable(response.NPCs, func(i, j int) bool {
|
|
left, leftOK := earliestSourceIndex(doc, response.NPCs[i])
|
|
right, rightOK := earliestSourceIndex(doc, response.NPCs[j])
|
|
if leftOK != rightOK {
|
|
return leftOK
|
|
}
|
|
if !leftOK {
|
|
return false
|
|
}
|
|
return left < right
|
|
})
|
|
}
|
|
|
|
func canonicalizeNPC(npc *npcResponse) {
|
|
if npc == nil {
|
|
return
|
|
}
|
|
sort.SliceStable(npc.SourceRefs, func(i, j int) bool {
|
|
left := npc.SourceRefs[i]
|
|
right := npc.SourceRefs[j]
|
|
if unitSortValue(left.StartUnitID) != unitSortValue(right.StartUnitID) {
|
|
return unitSortValue(left.StartUnitID) < unitSortValue(right.StartUnitID)
|
|
}
|
|
return unitSortValue(left.EndUnitID) < unitSortValue(right.EndUnitID)
|
|
})
|
|
npc.SourceRefs = dedupeSourceRefs(npc.SourceRefs)
|
|
}
|
|
|
|
func dedupeSourceRefs(refs []npcSourceRefResponse) []npcSourceRefResponse {
|
|
if len(refs) < 2 {
|
|
return refs
|
|
}
|
|
out := refs[:0]
|
|
var previous npcSourceRefResponse
|
|
for index, ref := range refs {
|
|
if index > 0 && sameSourceRef(previous, ref) {
|
|
continue
|
|
}
|
|
out = append(out, ref)
|
|
previous = ref
|
|
}
|
|
return out
|
|
}
|
|
|
|
func sameSourceRef(left npcSourceRefResponse, right npcSourceRefResponse) bool {
|
|
return left.StartUnitID == right.StartUnitID && left.EndUnitID == right.EndUnitID
|
|
}
|
|
|
|
func earliestSourceIndex(doc *source.SourceDocument, npc npcResponse) (int, bool) {
|
|
earliest := 0
|
|
found := false
|
|
for _, ref := range npc.SourceRefs {
|
|
start := ref.StartUnitID
|
|
end := ref.EndUnitID
|
|
if start > 0 && end > 0 {
|
|
startIndex, startOK := source.UnitIndex(doc, start)
|
|
endIndex, endOK := source.UnitIndex(doc, end)
|
|
if !startOK || !endOK || startIndex > endIndex {
|
|
continue
|
|
}
|
|
if !found || startIndex < earliest {
|
|
earliest = startIndex
|
|
found = true
|
|
}
|
|
}
|
|
}
|
|
return earliest, found
|
|
}
|
|
|
|
func unitSortValue(value int) int {
|
|
if value <= 0 {
|
|
return int(^uint(0) >> 1)
|
|
}
|
|
return value
|
|
}
|
|
|
|
func canonicalNPCList(response extractionResponse, sourceID string) dnd.NPCList {
|
|
if response.NPCs == nil {
|
|
return dnd.NPCList{NPCs: nil}
|
|
}
|
|
npcs := make([]dnd.NPC, len(response.NPCs))
|
|
for index, npc := range response.NPCs {
|
|
npcs[index] = dnd.NPC{
|
|
ID: identity.DeriveID(npc.Name),
|
|
Name: npc.Name,
|
|
SourceRefs: canonicalSourceRefs(npc.SourceRefs, sourceID),
|
|
}
|
|
}
|
|
return dnd.NPCList{NPCs: npcs}
|
|
}
|
|
|
|
func canonicalSourceRefs(values []npcSourceRefResponse, sourceID string) []source.SourceRef {
|
|
if values == nil {
|
|
return nil
|
|
}
|
|
out := make([]source.SourceRef, len(values))
|
|
for index, value := range values {
|
|
out[index] = source.SourceRef{
|
|
SourceID: sourceID,
|
|
StartUnitID: value.StartUnitID,
|
|
EndUnitID: value.EndUnitID,
|
|
}
|
|
}
|
|
return out
|
|
}
|