coh-content-db 2.0.0-rc.4 → 2.0.0-rc.6

package/src/main/db/alternates.ts

@@ -13,7 +13,7 @@ export class Alternates<T> {
     this.#sortedValues.sort((a, b) => this.#compareAlternates(a, b))
   }
 
-  getValue(alignment?: Alignment | string, sex?: Sex | string): T | undefined {
+  getValue(alignment?: Alignment, sex?: Sex): T | undefined {
     for (let index = this.#sortedValues.length; index--;) {
       const entry = this.#sortedValues[index]
       if ((entry.alignment === undefined || entry.alignment === alignment)
@@ -21,14 +21,14 @@ export class Alternates<T> {
       ) return entry.value
     }
 
-    return this.default
+    return this.default?.value
   }
 
   /**
    * Get the default value for this list of alternates, the value with the highest priority and lowest specificity.
    */
-  get default(): T | undefined {
-    return this.#sortedValues[0]?.value
+  get default(): AlternateData<T> | undefined {
+    return this.#sortedValues[0]
   }
 
   /**
@@ -60,7 +60,7 @@ export class Alternates<T> {
     return String(a.value).localeCompare(String(b.value))
   }
 
-  #compareAlignment(a: Alignment | string | undefined, b: Alignment | string | undefined): number {
+  #compareAlignment(a?: Alignment, b?: Alignment): number {
     if (a === b) return 0
     if (a === undefined && b !== undefined) return -1
     if (b === undefined && a !== undefined) return 1
@@ -68,13 +68,10 @@ export class Alternates<T> {
     const aSort = a === undefined ? -1 : ALIGNMENT_SORT[a] ?? -1 // Unknown values get -1 priority
     const bSort = b === undefined ? -1 : ALIGNMENT_SORT[b] ?? -1
 
-    if (aSort !== bSort) return bSort - aSort
-
-    // Unknown values (not in ALIGNMENT_SORT) are sorted alphabetically
-    return a?.localeCompare(b ?? '') ?? 0
+    return bSort - aSort
   }
 
-  #compareSex(a?: Sex | string | undefined, b?: Sex | string | undefined): number {
+  #compareSex(a?: Sex, b?: Sex): number {
     if (a === b) return 0
     if (a === undefined && b !== undefined) return -1
     if (b === undefined && a !== undefined) return 1
@@ -82,9 +79,6 @@ export class Alternates<T> {
     const aSort = SEX_SORT[a ?? -1] ?? -1 // Unknown values get -1 priority
     const bSort = SEX_SORT[b ?? -1] ?? -1
 
-    if (aSort !== bSort) return bSort - aSort
-
-    // Unknown values (not in SEX_SORT) are sorted alphabetically
-    return a?.localeCompare(b ?? '') ?? 0
+    return bSort - aSort
   }
 }

package/src/main/db/badge-index.ts

@@ -0,0 +1,93 @@
+import { Badge } from './badge'
+import { BadgeSearchOptions } from './badge-search-options'
+import { Zone } from './zone'
+import { Paged } from './paged'
+
+export class BadgeIndex {
+  readonly #badges: Badge[] = []
+  readonly #badgeIndex: Record<string, Badge> = {}
+
+  readonly #zoneOrder: Record<string, number> = {}
+
+  constructor(badges: Badge[], zones?: Zone[]) {
+    this.#zoneOrder = Object.fromEntries(
+      zones
+        ?.sort((a, b) => a.name.localeCompare(b.name))
+        ?.map((x, index) => [x.key, index]) ?? [],
+    )
+
+    this.#badges = badges
+    for (const badge of badges) {
+      if (this.#badgeIndex[badge.key] !== undefined) throw new Error(`Duplicate badge key [${badge.key}]`)
+      this.#badgeIndex[badge.key] = badge
+    }
+  }
+
+  getBadge(key: string): Badge {
+    const result = this.#badgeIndex[key]
+    if (result === undefined) throw new Error(`Unknown badge key [${key}]`)
+    return result
+  }
+
+  badgeExists(key: string): boolean {
+    return !!this.#badgeIndex[key]
+  }
+
+  searchBadges(options?: BadgeSearchOptions): Paged<Badge> {
+    const filtered = (options?.query || options?.filter)
+      ? this.#badges.filter(badge => this.#satisfiesQueryPredicate(badge, options?.query) && this.#satisfiesFilterPredicate(badge, options?.filter))
+      : this.#badges
+
+    const totalPages = options?.pageSize ? Math.ceil(filtered.length / (options?.pageSize)) : 1
+    const page = Math.max(1, Math.min(totalPages, options?.page ?? 1))
+    const paged = options?.pageSize ? filtered.slice((page - 1) * options.pageSize, page * options?.pageSize) : filtered
+
+    const sorted = this.#sort(paged, options?.sort)
+
+    return {
+      items: sorted,
+      page: page,
+      pageSize: options?.pageSize,
+      totalItems: filtered.length,
+      totalPages: totalPages,
+    }
+  }
+
+  #satisfiesQueryPredicate(badge: Badge, query?: BadgeSearchOptions['query']): boolean {
+    const queryString = query?.str?.toLowerCase() ?? ''
+    return !!(((query?.on?.name ?? true) && badge.name.canonical.some(x => x.value.toLowerCase().includes(queryString)))
+      || (query?.on?.badgeText && badge.badgeText.canonical.some(x => x.value.toLowerCase().includes(queryString)))
+      || (query?.on?.acquisition && badge.acquisition?.toLowerCase().includes(queryString))
+      || (query?.on?.effect && badge.effect?.toLowerCase().includes(queryString))
+      || (query?.on?.notes && badge.notes?.toLowerCase().includes(queryString))
+      || (query?.on?.setTitle && (badge.setTitle?.id?.toString().includes(queryString) || badge.setTitle?.praetorianId?.toString().includes(queryString))))
+  }
+
+  #satisfiesFilterPredicate(badge: Badge, filter?: BadgeSearchOptions['filter']): boolean {
+    return (!filter?.type || badge.type === filter.type)
+      && (!filter?.zoneKey || badge.zoneKey === filter.zoneKey)
+      && (!filter?.alignment || badge.alignment.items.includes(filter.alignment))
+  }
+
+  #sort(badges: Badge[], sort?: BadgeSearchOptions['sort']): Badge[] {
+    if (!sort) return badges
+    const ascending = sort.dir !== 'DESC'
+
+    if (!sort.by || sort.by === 'CANONICAL') return sort.dir === 'DESC' ? badges.reverse() : badges
+
+    if (sort.by === 'BADGE_NAME') return ascending
+      ? badges.sort((a, b) => a.name.default?.value.localeCompare(b.name.default?.value ?? '') ?? 0)
+      : badges.sort((a, b) => b.name.default?.value.localeCompare(a.name.default?.value ?? '') ?? 0)
+
+    return badges.sort((a, b) => {
+      const aIndex = this.#zoneOrder[a.zoneKey ?? '']
+      const bIndex = this.#zoneOrder[b.zoneKey ?? '']
+
+      if (aIndex === bIndex) return 0
+      if (aIndex === undefined) return ascending ? 1 : -1
+      if (bIndex === undefined) return ascending ? -1 : 1
+
+      return ascending ? aIndex - bIndex : bIndex - aIndex
+    })
+  }
+}

package/src/main/db/badge-requirement.ts

@@ -0,0 +1,102 @@
+import { BadgeRequirementData } from '../api/badge-requirement-data'
+import { PlaqueType } from '../api/plaque-type'
+import { BadgeRequirementType } from '../api/badge-requirement-type'
+import { EnhancementCategory } from '../api/enhancement-category'
+import { Key } from './key'
+import { MarkdownString } from '../api/markdown-string'
+import { Link } from '../api/link'
+
+export class BadgeRequirement {
+  /**
+   * Key.
+   */
+  readonly key: string
+
+  /**
+   * Type of requirement.
+   */
+  readonly type: BadgeRequirementType
+
+  /**
+   * Zone the requirement is located in.
+   */
+  readonly zoneKey?: string
+
+  /**
+   * /loc coordinates.
+   */
+  readonly loc?: number[]
+
+  /**
+   * Is it a wall plaque or a physical monument?
+   */
+  readonly plaqueType?: PlaqueType
+
+  /**
+   * Plaque inscription.
+   */
+  readonly plaqueInscription?: string
+
+  /**
+   * The number or letter the plaque appears as on Vidiot Maps.
+   */
+  readonly vidiotMapKey?: string
+
+  /**
+   * The key of the badge for this requirement.
+   */
+  readonly badgeKey?: string
+
+  /**
+   * Mission name.
+   */
+  readonly missionName?: string
+
+  /**
+   * {@link Contact} key for the story arc.
+   */
+  readonly contactKey?: string
+
+  /**
+   * Level of the invention required.
+   */
+  readonly inventionLevel?: number
+
+  /**
+   * The types of enhancements required to be crafted.
+   */
+  readonly inventionTypes?: EnhancementCategory[]
+
+  /**
+   * Number of invention crafts required.
+   */
+  readonly inventionCount?: number
+
+  /**
+   * Any additional notes.
+   */
+  readonly notes?: MarkdownString
+
+  /**
+   * List of external links. Wiki, forums, etc.
+   */
+  readonly links: Link[]
+
+  constructor(data: BadgeRequirementData) {
+    this.key = new Key(data.key).value
+    this.type = data.type
+    this.zoneKey = data.zoneKey
+    this.loc = data.loc
+    this.plaqueType = data.plaqueType
+    this.plaqueInscription = data.plaqueInscription
+    this.vidiotMapKey = data.vidiotMapKey
+    this.badgeKey = data.badgeKey
+    this.missionName = data.missionName
+    this.contactKey = data.contactKey
+    this.inventionLevel = data.inventionLevel
+    this.inventionTypes = data.inventionTypes
+    this.inventionCount = data.inventionCount
+    this.notes = data.notes
+    this.links = data.links ?? []
+  }
+}

package/src/main/db/badge-search-options.ts

@@ -0,0 +1,51 @@
+import { BadgeType } from '../api/badge-type'
+import { Alignment } from '../api/alignment'
+
+export interface BadgeSearchOptions {
+
+  /**
+   * Text-based search.
+   *
+   * Case-insensitive. Defaults to searching on name only.
+   */
+  query?: {
+    str?: string
+    on?: {
+      name?: boolean
+      badgeText?: boolean
+      acquisition?: boolean
+      notes?: boolean
+      effect?: boolean
+      setTitle?: boolean
+    }
+  }
+
+  /**
+   * Filter results matching the given values.
+   */
+  filter?: {
+    type?: BadgeType
+    zoneKey?: string
+    alignment?: Alignment
+  }
+
+  /**
+   * Sort results.
+   *
+   * Badges are assumed to be in canonical order in the content bundle, and should match the in-game display order.
+   */
+  sort?: {
+    by?: 'CANONICAL' | 'BADGE_NAME' | 'ZONE_NAME'
+    dir?: 'ASC' | 'DESC'
+  }
+
+  /**
+   * The page (1-based)
+   */
+  page?: number
+
+  /**
+   * How many results per page
+   */
+  pageSize?: number
+}

package/src/main/db/badge.ts

@@ -1,13 +1,14 @@
 import { BadgeType } from '../api/badge-type'
-import { Alignment } from '../api/alignment'
 import { Link } from '../api/link'
 import { BadgeData } from '../api/badge-data'
-import { BadgePartial } from './badge-partial'
+import { BadgeRequirement } from './badge-requirement'
 import { Key } from './key'
 import { Alternates } from './alternates'
+import { Alignments } from './alignments'
+import { MarkdownString } from '../api/markdown-string'
 
 export class Badge {
-  readonly #partialsIndex: Record<string, BadgePartial> = {}
+  readonly #requirementsIndex: Record<string, BadgeRequirement> = {}
 
   /**
    * The database key for this badge.
@@ -17,7 +18,7 @@ export class Badge {
   /**
    * The type of badge.
    */
-  readonly type: BadgeType | string
+  readonly type: BadgeType
 
   /**
    * The name of this badge.
@@ -29,7 +30,7 @@ export class Badge {
   /**
    * The character alignments that this badge is available to.
    */
-  readonly alignment: Alignment[]
+  readonly alignment: Alignments
 
   /**
    * The badge text as it appears in-game. May vary by character sex or alignment.
@@ -37,11 +38,9 @@ export class Badge {
   readonly badgeText: Alternates<string>
 
   /**
-   * Description of how to acquire the badge.
-   *
-   * Supports {@link https://www.markdownguide.org/|Markdown} format.
+   * Short description of how to acquire the badge. Detailed instructions will be in the notes field.
    */
-  readonly acquisition?: string
+  readonly acquisition?: MarkdownString
 
   /**
    * Absolute URL to this badge's icon.
@@ -52,28 +51,26 @@ export class Badge {
 
   /**
    * Freeform notes or tips about the badge.
-   *
-   * Supports {@link https://www.markdownguide.org/|Markdown} format.
    */
-  readonly notes?: string
+  readonly notes?: MarkdownString
 
   /**
-   * List of external links for this Badge. Wiki, forums, etc.
+   * List of external links. Wiki, forums, etc.
    */
-  readonly links?: Link[]
+  readonly links: Link[]
 
   /**
-   * For exploration badges, the key of the {@link GameMap} that this badge is found on.
+   * For exploration badges, the key of the {@link Zone} that this badge is found on.
    */
-  readonly mapKey?: string
+  readonly zoneKey?: string
 
   /**
-   * For exploration badges, the `/loc` coordinates of the badge on the in-game map.
+   * For exploration badges, the `/loc` coordinates of the badge.
    */
   readonly loc?: [number, number, number]
 
   /**
-   * For badges that appear on a Vidiot Map, the number or letter the badge appears as.
+   * For plaques that appear on a Vidiot Map, the number or letter the badge appears as.
    */
   readonly vidiotMapKey?: string
 
@@ -93,49 +90,59 @@ export class Badge {
 
   /**
    * A description of the effect the badge will have, such as a buff or granting a temporary power.
-   *
-   * Supports {@link https://www.markdownguide.org/|Markdown} format.
    */
-  readonly effect?: string
+  readonly effect?: MarkdownString
 
   /**
-   * A list of requirements for badges that have partial fulfilment steps, such as visiting plaques for history badges, or collecting other badges for meta-badges like accolades.
+   * Represents the layered requirements for badges with multiple fulfillment steps,
+   * such as visiting plaques for history badges or collecting other badges.
+   *
+   * The outer array represents groups of requirements evaluated with OR logic —
+   * fulfilling any group satisfies the badge.
+   *
+   * Each inner array represents individual requirements evaluated with AND logic —
+   * all conditions in the group must be met.
    */
-  readonly partials?: BadgePartial[]
+  readonly requirements?: BadgeRequirement[][]
 
   /**
    * Some badges are not included in the badge total count... such as Flames of Prometheus, which can be removed by redeeming it for a Notice of the Well.
    */
   readonly ignoreInTotals: boolean
 
-  constructor(data: BadgeData) {
-    this.key = new Key(data.key).value
-    this.type = data.type
-    this.name = new Alternates(data.name)
-    this.alignment = data.alignment
-    this.badgeText = new Alternates(data.badgeText ?? [])
-    this.acquisition = data.acquisition
-    this.icon = new Alternates(data.icon ?? [])
-    this.notes = data.notes
-    this.links = data.links
-    this.mapKey = data.mapKey
-    this.loc = data.loc
-    this.effect = data.effect
-    this.vidiotMapKey = data.vidiotMapKey
-    this.setTitle = data.setTitle
-    this.ignoreInTotals = data.ignoreInTotals ?? false
-
-    this.partials = data.partials?.map((data) => {
-      if (this.#partialsIndex[data.key] !== undefined) throw new Error(`Duplicate badge partial key [${data.key}]`)
-      const badge = new BadgePartial(data)
-      this.#partialsIndex[badge.key] = badge
-      return badge
+  constructor(badgeData: BadgeData) {
+    this.key = new Key(badgeData.key).value
+    this.type = badgeData.type
+    this.name = new Alternates(badgeData.name)
+    this.alignment = new Alignments(badgeData.alignment)
+    this.badgeText = new Alternates(badgeData.badgeText ?? [])
+    this.acquisition = badgeData.acquisition
+    this.icon = new Alternates(badgeData.icon ?? [])
+    this.notes = badgeData.notes
+    this.links = badgeData.links ?? []
+    this.zoneKey = badgeData.zoneKey
+    this.loc = badgeData.loc
+    this.effect = badgeData.effect
+    this.vidiotMapKey = badgeData.vidiotMapKey
+    this.setTitle = badgeData.setTitle
+    this.ignoreInTotals = badgeData.ignoreInTotals ?? false
+
+    this.requirements = badgeData.requirements?.map((groups, index) => {
+      const existingKeysInGroup = new Set<string>()
+      return groups.map((requirementData) => {
+        if (existingKeysInGroup.has(requirementData.key)) throw new Error(`Duplicate badge requirement key [${badgeData.key}:${requirementData.key}] in group [${index + 1}]`)
+        existingKeysInGroup.add(requirementData.key)
+
+        const badge = new BadgeRequirement(requirementData)
+        this.#requirementsIndex[badge.key] = badge
+        return badge
+      })
     })
   }
 
-  getPartial(key: string): BadgePartial {
-    const result = this.#partialsIndex[key]
-    if (result === undefined) throw new Error(`Unknown badge partial key [${key}]`)
+  getRequirement(key: string): BadgeRequirement {
+    const result = this.#requirementsIndex[key]
+    if (result === undefined) throw new Error(`Unknown badge requirement key [${key}]`)
     return result
   }
 }

package/src/main/db/bundle-metadata.ts

@@ -1,19 +1,18 @@
 import { ContentBundle } from '../api/content-bundle'
 import { Change } from '../api/change'
 import { Link } from '../api/link'
+import { MarkdownString } from '../api/markdown-string'
 
 export class BundleMetadata {
   /**
-   * Name of the server group.
+   * Name of the content bundle.
    */
   readonly name: string
 
   /**
-   * Description of the server group.
-   *
-   * Supports {@link https://www.markdownguide.org/|Markdown} format.
+   * Description of the fork.
    */
-  readonly description?: string
+  readonly description?: MarkdownString
 
   /**
    * Repository where the db content package is maintained.
@@ -21,7 +20,7 @@ export class BundleMetadata {
   readonly repository?: string
 
   /**
-   * List of external links for this Server Group. Wiki, forums, etc.
+   * List of external links. Wiki, forums, etc.
    */
   readonly links: Link[]
 

package/src/main/db/coh-content-database.ts

@@ -1,16 +1,18 @@
 import { ContentBundle } from '../api/content-bundle'
 import { Archetype } from './archetype'
-import { GameMap } from './game-map'
+import { Zone } from './zone'
 import { Badge } from './badge'
 import { BundleMetadata } from './bundle-metadata'
-import MiniSearch from 'minisearch'
-import { BadgeSearchDocument } from './badge-search-document'
+import { BadgeIndex } from './badge-index'
+import { BadgeSearchOptions } from './badge-search-options'
+import { Paged } from './paged'
+import { Contact } from './contact'
 
 export class CohContentDatabase {
   readonly #archetypeIndex: Record<string, Archetype> = {}
-  readonly #mapIndex: Record<string, GameMap> = {}
-  readonly #badgeIndex: Record<string, Badge> = {}
-  readonly #badgeSearch: MiniSearch
+  readonly #zoneIndex: Record<string, Zone> = {}
+  readonly #contactIndex: Record<string, Contact> = {}
+  readonly #badgeIndex: BadgeIndex
 
   /**
    * Metadata about the content bundle.
@@ -18,23 +20,29 @@ export class CohContentDatabase {
   readonly metadata: BundleMetadata
 
   /**
-   * List of the game server names in this server group.
+   * List of the game server names.
+   *
    * Torchbearer, Excelsior, etc.
    */
   readonly servers: string[]
 
   /**
-   * List of archetypes available in this server group.
+   * List of archetypes.
    */
   readonly archetypes: Archetype[]
 
   /**
-   * List of game maps supported by this server group.
+   * List of game zones.
    */
-  readonly maps: GameMap[]
+  readonly zones: Zone[]
 
   /**
-   * List of badges available on this server group.
+   * List of contacts.
+   */
+  readonly contacts: Contact[]
+
+  /**
+   * List of badges.
    */
   readonly badges: Badge[]
 
@@ -45,56 +53,73 @@ export class CohContentDatabase {
   constructor(bundle: ContentBundle) {
     this.metadata = new BundleMetadata(bundle)
     this.servers = bundle.servers ?? []
+
     this.archetypes = bundle.archetypes?.map((data) => {
-      if (this.#archetypeIndex[data.key] !== undefined) throw new Error(`Duplicate archetype key [${data.key}]`)
+      if (this.#archetypeIndex[data.key] !== undefined) throw new Error(`Duplicate archetype key '${data.key}'`)
       const archetype = new Archetype(data)
       this.#archetypeIndex[archetype.key] = archetype
       return archetype
     }) ?? []
-    this.maps = bundle.maps?.map((data) => {
-      if (this.#mapIndex[data.key] !== undefined) throw new Error(`Duplicate map key [${data.key}]`)
-      const map = new GameMap(data)
-      this.#mapIndex[map.key] = map
-      return map
+
+    this.zones = bundle.zones?.map((data) => {
+      if (this.#zoneIndex[data.key] !== undefined) throw new Error(`Duplicate zone key '${data.key}'`)
+      const zone = new Zone(data)
+      this.#zoneIndex[zone.key] = zone
+      return zone
     }) ?? []
-    this.badges = bundle.badges?.map((data) => {
-      if (this.#badgeIndex[data.key] !== undefined) throw new Error(`Duplicate badge key [${data.key}]`)
-      const badge = new Badge(data)
-      this.#badgeIndex[badge.key] = badge
-      return badge
+
+    this.contacts = bundle.contacts?.map((data) => {
+      if (this.#contactIndex[data.key] !== undefined) throw new Error(`Duplicate contact key '${data.key}'`)
+      const contact = new Contact(data)
+      this.#contactIndex[contact.key] = contact
+      return contact
     }) ?? []
 
-    this.#badgeSearch = new MiniSearch({
-      fields: ['key', 'name', 'badgeText', 'acquisition'],
-      storeFields: ['key'],
-    })
-    for (const badge of this.badges) {
-      this.#badgeSearch.add(new BadgeSearchDocument(badge))
-    }
+    this.badges = bundle.badges?.map(data => new Badge(data)) ?? []
+    this.#badgeIndex = new BadgeIndex(this.badges, this.zones)
   }
 
   getArchetype(key: string): Archetype {
     const result = this.#archetypeIndex[key]
-    if (result === undefined) throw new Error(`Unknown archetype key [${key}]`)
+    if (result === undefined) throw new Error(`Unknown archetype key '${key}'`)
     return result
   }
 
-  getMap(key: string): GameMap {
-    const result = this.#mapIndex[key]
-    if (result === undefined) throw new Error(`Unknown map key [${key}]`)
+  getZone(key: string): Zone {
+    const result = this.#zoneIndex[key]
+    if (result === undefined) throw new Error(`Unknown zone key '${key}'`)
     return result
   }
 
-  getBadge(key: string): Badge {
-    const result = this.#badgeIndex[key]
-    if (result === undefined) throw new Error(`Unknown badge key [${key}]`)
+  getContact(key: string): Contact {
+    const result = this.#contactIndex[key]
+    if (result === undefined) throw new Error(`Unknown contact key '${key}'`)
     return result
   }
 
-  searchBadges(query?: string): Badge[] {
-    if (!query) return this.badges
-    const keys = this.#badgeSearch.search(query, { prefix: true, fuzzy: true })
+  zoneExists(key: string): boolean {
+    return !!this.#zoneIndex[key]
+  }
 
-    return keys.map(result => this.getBadge(result['key']))
+  contactExists(key: string): boolean {
+    return !!this.#contactIndex[key]
+  }
+
+  getBadge(key: string): Badge {
+    return this.#badgeIndex.getBadge(key)
+  }
+
+  badgeExists(key: string): boolean {
+    return this.#badgeIndex.badgeExists(key)
+  }
+
+  /**
+   * Search, sort and filter the badge list.
+   * This is a fairly brute-forced approach and will not be as performant as loading the badge data into a traditional
+   * database engine, but is sufficient for most operations.
+   * @param options {@link BadgeSearchOptions}
+   */
+  searchBadges(options?: BadgeSearchOptions): Paged<Badge> {
+    return this.#badgeIndex.searchBadges(options)
   }
 }