coh-content-db 2.0.0-rc.2 → 2.0.0-rc.21

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

@@ -0,0 +1,83 @@
+import { Badge, compareByName, compareByReleaseDate, compareByZoneKey } from './badge'
+import { BadgeSearchOptions } from './badge-search-options'
+import { Paged } from './paged'
+import { AbstractIndex } from './abstract-index'
+
+export class BadgeIndex extends AbstractIndex<Badge> {
+  constructor(values: Badge[] | undefined) {
+    super('key', values)
+  }
+
+  search(options?: BadgeSearchOptions): Paged<Badge> {
+    const matched = (options?.query || options?.filter)
+      ? this._values.filter(badge => this.#satisfiesQueryPredicate(badge, options?.query) && this.#satisfiesFilterPredicate(badge, options?.filter))
+      : this._values
+
+    const sorted = this.#sort(matched, options)
+
+    const totalPages = options?.pageSize ? Math.ceil(matched.length / (options?.pageSize)) : 1
+    const pageNumber = Math.max(1, Math.min(totalPages, options?.page ?? 1))
+    const items = options?.pageSize ? sorted.slice((pageNumber - 1) * options.pageSize, pageNumber * options?.pageSize) : sorted
+
+    return {
+      items: items,
+      pageIndex: pageNumber - 1,
+      pageNumber: pageNumber,
+      pageSize: options?.pageSize,
+      matchedItemCount: matched.length,
+      totalItemCount: this._values.length,
+      totalPageCount: totalPages,
+    }
+  }
+
+  #satisfiesQueryPredicate(badge: Badge, query?: BadgeSearchOptions['query']): boolean {
+    const queryString = query?.str?.toLowerCase() ?? ''
+    const fields = query?.fields ? new Set(query?.fields) : new Set(['name']) // Default to name if not provided
+    if (fields.size === 0) return true
+
+    return !!((fields.has('name') && badge.name.canonical.some(x => x.value.toLowerCase().includes(queryString)))
+      || (fields.has('badge-text') && badge.badgeText.canonical.some(x => x.value.toLowerCase().includes(queryString)))
+      || (fields.has('acquisition') && badge.acquisition?.toLowerCase().includes(queryString))
+      || (fields.has('effect') && badge.effect?.toLowerCase().includes(queryString))
+      || (fields.has('notes') && badge.notes?.toLowerCase().includes(queryString))
+      || (fields.has('set-title-id') && (badge.setTitleId?.primal.toString() === queryString))
+      || (fields.has('set-title-id') && (badge.setTitleId?.praetorian?.toString() === queryString))
+    )
+  }
+
+  #satisfiesFilterPredicate(badge: Badge, filter?: BadgeSearchOptions['filter']): boolean {
+    return (!filter?.type || badge.type === filter.type)
+      && (!filter?.zoneKey || badge.zoneKey === filter.zoneKey)
+      && (!filter?.morality || badge.morality.has(filter.morality))
+      && (!filter?.predicate || filter.predicate(badge))
+  }
+
+  #sort(badges: Badge[], options?: BadgeSearchOptions): Badge[] {
+    switch (options?.sort) {
+      case 'name.asc': {
+        return badges.toSorted((a, b) => compareByName(a, b, options.variantContext))
+      }
+      case 'name.desc': {
+        return badges.toSorted((a, b) => compareByName(b, a, options.variantContext))
+      }
+      case 'zone-key.asc': {
+        return badges.toSorted(compareByZoneKey)
+      }
+      case 'zone-key.desc': {
+        return badges.toSorted((a, b) => compareByZoneKey(b, a))
+      }
+      case 'release-date.asc': {
+        return badges.toSorted(compareByReleaseDate)
+      }
+      case 'release-date.desc': {
+        return badges.toSorted((a, b) => compareByReleaseDate(b, a))
+      }
+      case 'canonical.desc': {
+        return badges.toReversed()
+      }
+      default: {
+        return [...badges]
+      }
+    }
+  }
+}

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

@@ -0,0 +1,81 @@
+import { BadgeRequirementData } from '../api/badge-requirement-data'
+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'
+import { Location } from './location'
+import { coalesceToArray } from '../util/coalesce-to-array'
+
+export class BadgeRequirement {
+  /**
+   * Unique key used to reference this badge requirement.
+   *
+   * Keys must be unique and can only contain lowercase letters, numbers and hyphens (`-`).
+   */
+  readonly key: string
+
+  /**
+   * The requirement type.
+   */
+  readonly type: BadgeRequirementType
+
+  /**
+   * If the requirement involves a location, where it is.
+   */
+  readonly location?: Location[]
+
+  /**
+   * If the requirement involves a badge, the badge key.
+   */
+  readonly badgeKey?: string
+
+  /**
+   * If the requirement involves a mission, the mission key.
+   */
+  readonly missionKey?: string
+
+  /**
+   * If the requirement involves a monument, the text that is displayed thereon.
+   */
+  readonly monumentText?: string
+
+  /**
+   * If the requirement involves crafting an invention, the Level of the invention required.
+   */
+  readonly inventionLevel?: number
+
+  /**
+   * If the requirement involves crafting an invention, the types of enhancements that will qualify.
+   */
+  readonly inventionTypes?: EnhancementCategory[]
+
+  /**
+   * Number of times the task needs to be repeated.
+   */
+  readonly count?: number
+
+  /**
+   * Additional information about the requirement.
+   */
+  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.location = coalesceToArray(data.location)
+    this.badgeKey = data.badgeKey
+    this.missionKey = data.missionKey
+    this.monumentText = data.monumentText
+    this.inventionLevel = data.inventionLevel
+    this.inventionTypes = data.inventionTypes
+    this.count = data.count
+    this.notes = data.notes
+    this.links = data.links ?? []
+  }
+}

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

@@ -0,0 +1,52 @@
+import { BadgeType } from '../api/badge-type'
+import { Morality } from '../api/morality'
+import { Badge } from './badge'
+import { VariantContext } from '../api/variant-context'
+
+export type BadgeQueryableField = 'name' | 'badge-text' | 'acquisition' | 'notes' | 'effect' | 'set-title-id'
+export type BadgeSort = `${'canonical' | 'name' | 'zone-key' | 'release-date'}.${'asc' | 'desc'}`
+
+export interface BadgeSearchOptions {
+
+  /**
+   * Text-based search.
+   *
+   * Case-insensitive. Defaults to searching on name only.
+   */
+  query?: {
+    str?: string
+    fields?: BadgeQueryableField[]
+  }
+
+  /**
+   * Filter results matching the given values.
+   */
+  filter?: {
+    type?: BadgeType
+    zoneKey?: string
+    morality?: Morality
+    predicate?: (badge: Badge) => boolean
+  }
+
+  /**
+   * Adjust search results based on a given variant context (morality or sex of a character).
+   */
+  variantContext?: VariantContext
+
+  /**
+   * Sort results.
+   *
+   * Badges are assumed to be in canonical order in the content bundle, and should match the in-game display order.
+   */
+  sort?: BadgeSort
+
+  /**
+   * The page (1-based)
+   */
+  page?: number
+
+  /**
+   * How many results per page
+   */
+  pageSize?: number
+}

package/src/main/db/badge.ts

@@ -1,13 +1,20 @@
 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 { Variants } from './variants'
+import { MarkdownString } from '../api/markdown-string'
+import { MoralityList } from './morality-list'
+import { AbstractIndex } from './abstract-index'
+import { toDate } from '../util/to-date'
+import { coalesceToArray } from '../util/coalesce-to-array'
+import { SetTitleIds } from './set-title-ids'
+import { VariantContext } from '../api/variant-context'
 
 export class Badge {
-  readonly #partialsIndex: Record<string, BadgePartial> = {}
+  readonly #requirementsIndex: AbstractIndex<BadgeRequirement>
+  readonly #zoneKeys = new Set<string>()
 
   /**
    * The database key for this badge.
@@ -17,125 +24,141 @@ export class Badge {
   /**
    * The type of badge.
    */
-  readonly type: BadgeType | string
+  readonly type: BadgeType
 
   /**
    * The name of this badge.
    *
    * May vary by character sex or alignment.
    */
-  readonly name: Alternates<string>
+  readonly name: Variants<string>
 
   /**
-   * The character alignments that this badge is available to.
+   * The date that the badge was added to the game.
    */
-  readonly alignment: Alignment[]
+  readonly releaseDate: Date
+
+  /**
+   * The character moralities that this badge is available to.
+   */
+  readonly morality: MoralityList
 
   /**
    * The badge text as it appears in-game. May vary by character sex or alignment.
    */
-  readonly badgeText: Alternates<string>
+  readonly badgeText: Variants<MarkdownString>
 
   /**
-   * 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.
    *
    * May vary by character sex or alignment.
    */
-  readonly icon: Alternates<string>
+  readonly icon: Variants<string>
 
   /**
    * 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.
+   * The id used with the in-game `/settitle` command to apply the badge.
+   * The first value is the id for primal characters and the (optional) second number is the id for praetorian characters.
    */
-  readonly mapKey?: string
+  readonly setTitleId?: SetTitleIds
 
   /**
-   * For exploration badges, the `/loc` coordinates of the badge on the in-game map.
+   * A description of the effect the badge will have, such as a buff or granting a temporary power.
    */
-  readonly loc?: [number, number, number]
+  readonly effect?: MarkdownString
 
   /**
-   * For badges that appear on a Vidiot Map, the number or letter the badge appears as.
+   * 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 vidiotMapKey?: string
+  readonly ignoreInTotals: boolean
 
-  /**
-   * ID used with the in-game `/settitle` command to apply the badge.
-   */
-  readonly setTitle?: {
-    /**
-     * `/settitle` id.
-     */
-    id?: number
-    /**
-     * `/settitle` id if different for praetorian characters.
-     */
-    praetorianId?: number
+  constructor(badgeData: BadgeData) {
+    this.key = new Key(badgeData.key).value
+    this.type = badgeData.type
+    this.name = new Variants(badgeData.name)
+    this.releaseDate = toDate(badgeData.releaseDate)
+    this.morality = new MoralityList(coalesceToArray(badgeData.morality))
+    this.badgeText = new Variants(badgeData.badgeText ?? [])
+    this.acquisition = badgeData.acquisition
+    this.icon = new Variants(badgeData.icon ?? [])
+    this.notes = badgeData.notes
+    this.links = badgeData.links ?? []
+    this.effect = badgeData.effect
+    this.setTitleId = badgeData.setTitleId ? new SetTitleIds(badgeData.setTitleId) : undefined
+    this.ignoreInTotals = badgeData.ignoreInTotals ?? false
+
+    this.#requirementsIndex = new AbstractIndex<BadgeRequirement>('key', badgeData.requirements?.map(x => new BadgeRequirement(x)))
+
+    for (const requirement of this.#requirementsIndex.values) {
+      if (requirement.location) for (const location of requirement.location) {
+        if (location.zoneKey) this.#zoneKeys.add(location.zoneKey)
+      }
+    }
   }
 
   /**
-   * 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.
+   * Represents the requirements for badges with multiple fulfillment steps, such as visiting monuments for history badges, completing missions, or collecting other badges.
    */
-  readonly effect?: string
+  get requirements(): BadgeRequirement[] {
+    return this.#requirementsIndex.values
+  }
+
+  getRequirement(key: string): BadgeRequirement | undefined {
+    return this.#requirementsIndex.get(key)
+  }
 
   /**
-   * 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.
+   * Return a list of all the zone keys referenced by this badge.
    */
-  readonly partials?: BadgePartial[]
+  get zoneKeys(): string[] {
+    return [...this.#zoneKeys]
+  }
 
   /**
-   * 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.
+   * The zone key if this badge relates to a single zone.
    */
-  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
-    })
+  get zoneKey(): string | undefined {
+    return this.#zoneKeys.size === 1 ? this.#zoneKeys.values().next().value : undefined
   }
+}
 
-  getPartial(key: string): BadgePartial {
-    const result = this.#partialsIndex[key]
-    if (result === undefined) throw new Error(`Unknown badge partial key [${key}]`)
-    return result
-  }
+export function compareByName(a?: Badge, b?: Badge, context?: VariantContext): number {
+  const aName = a?.name?.getValue(context)
+  const bName = b?.name?.getValue(context)
+  if (!aName && !bName) return 0
+  if (!aName) return 1
+  if (!bName) return -1
+  return aName.localeCompare(bName)
+}
+
+export function compareByZoneKey(a?: Badge, b?: Badge): number {
+  const aZone = a?.zoneKey
+  const bZone = b?.zoneKey
+  if (!aZone && !bZone) return 0
+  if (!aZone) return 1
+  if (!bZone) return -1
+  return aZone.localeCompare(bZone)
+}
+
+export function compareByReleaseDate(a?: Badge, b?: Badge): number {
+  const aReleaseDate = a?.releaseDate?.getTime()
+  const bReleaseDate = b?.releaseDate?.getTime()
+  if (aReleaseDate === bReleaseDate) return 0
+  if (!aReleaseDate) return 1
+  if (!bReleaseDate) return -1
+  return aReleaseDate < bReleaseDate ? -1 : 1
 }

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

@@ -0,0 +1,52 @@
+import { Link } from '../api/link'
+import { MarkdownString } from '../api/markdown-string'
+import { BundleHeaderData } from '../api/bundle-header-data'
+import { toDate } from '../util/to-date'
+
+export class BundleHeader {
+  /**
+   * Name of the fork this bundle contains data for.
+   */
+  readonly name: string
+
+  /**
+   * Version number for this data package.
+   */
+  readonly version: string
+
+  /**
+   * The time this bundle was last updated.
+   */
+  readonly lastUpdateTime: Date
+
+  /**
+   * Description of the fork.
+   */
+  readonly description?: MarkdownString
+
+  /**
+   * Url for the repository where the bundle is maintained.
+   */
+  readonly repositoryUrl?: string
+
+  /**
+   * Url for the location of the changelog.
+   */
+  readonly changelogUrl?: string
+
+  /**
+   * List of external links. Wiki, forums, etc.
+   */
+  readonly links?: Link[]
+
+  constructor(data: BundleHeaderData) {
+    if (!data) throw new Error('Missing header data')
+    this.name = data.name
+    this.version = data.version
+    this.lastUpdateTime = toDate(data.lastUpdateTime)
+    this.description = data?.description
+    this.repositoryUrl = data?.repositoryUrl
+    this.changelogUrl = data?.changelogUrl
+    this.links = data?.links ?? []
+  }
+}

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

@@ -1,29 +1,138 @@
-import { ServerGroup } from './server-group'
-import { ServerGroupData } from '../api/server-group-data'
+import { BundleData } from '../api/bundle-data'
+import { Archetype } from './archetype'
+import { Zone } from './zone'
+import { Badge } from './badge'
+import { BundleHeader } from './bundle-header'
+import { BadgeSearchOptions } from './badge-search-options'
+import { Paged } from './paged'
+import { Contact } from './contact'
+import { Mission } from './mission'
+import { AbstractIndex } from './abstract-index'
+import { BadgeIndex } from './badge-index'
 
 export class CohContentDatabase {
-  readonly #serverGroups: Record<string, ServerGroup> = {}
+  readonly #archetypeIndex
+  readonly #zoneIndex
+  readonly #contactIndex
+  readonly #missionIndex
+  readonly #badgeIndex
+
+  readonly #header: BundleHeader
+  readonly #servers: string[]
+
+  /**
+   * Create a db instance from the given content bundle.
+   * @param bundle The bundle to load.
+   */
+  constructor(bundle: BundleData) {
+    this.#header = new BundleHeader(bundle.header)
+    this.#servers = bundle.servers ?? []
+
+    this.#archetypeIndex = new AbstractIndex<Archetype>('key', bundle.archetypes?.map(x => new Archetype(x)))
+    this.#zoneIndex = new AbstractIndex<Zone>('key', bundle.zones?.map(x => new Zone(x)))
+    this.#contactIndex = new AbstractIndex<Contact>('key', bundle.contacts?.map(x => new Contact(x)))
+    this.#missionIndex = new AbstractIndex<Mission>('key', bundle.missions?.map(x => new Mission(x)))
+    this.#badgeIndex = new BadgeIndex(bundle.badges?.map(x => new Badge(x)))
+  }
+
+  /**
+   * Header information about the content bundle.
+   */
+  get header(): BundleHeader {
+    return this.#header
+  }
+
+  /**
+   * List of the game server names.
+   *
+   * Torchbearer, Excelsior, etc.
+   */
+  get servers(): string[] {
+    return this.#servers
+  }
+
+  /**
+   * List of archetypes.
+   */
+  get archetypes(): Archetype[] {
+    return this.#archetypeIndex.values
+  }
+
+  /**
+   * Get archetype by key.
+   * @param key The key.
+   */
+  getArchetype(key: string | undefined): Archetype | undefined {
+    return this.#archetypeIndex.get(key)
+  }
+
+  /**
+   * List of game zones.
+   */
+  get zones(): Zone[] {
+    return this.#zoneIndex.values
+  }
+
+  /**
+   * Get zone by key.
+   * @param key The key.
+   */
+  getZone(key: string | undefined): Zone | undefined {
+    return this.#zoneIndex.get(key)
+  }
+
+  /**
+   * List of contacts.
+   */
+  get contacts(): Contact[] {
+    return this.#contactIndex.values
+  }
+
+  /**
+   * Get contact by key.
+   * @param key The key.
+   */
+  getContact(key: string | undefined): Contact | undefined {
+    return this.#contactIndex.get(key)
+  }
+
+  /**
+   * List of missions.
+   */
+  get missions(): Mission[] {
+    return this.#missionIndex.values
+  }
+
+  /**
+   * Get mission by key.
+   * @param key The key.
+   */
+  getMission(key: string | undefined): Mission | undefined {
+    return this.#missionIndex.get(key)
+  }
 
   /**
-   * Load a server group data package into the database.
-   * @param data The data to load.
+   * List of badges.
    */
-  loadServerGroupData(data: ServerGroupData): void {
-    this.#serverGroups[data.key] = new ServerGroup(data)
+  get badges(): Badge[] {
+    return this.#badgeIndex.values
   }
 
   /**
-   * Get all the server groups currently loaded in the database.
+   * Get badge by key.
+   * @param key The key.
    */
-  listServerGroups(): ServerGroup[] {
-    return Object.values(this.#serverGroups)
+  getBadge(key: string | undefined): Badge | undefined {
+    return this.#badgeIndex.get(key)
   }
 
   /**
-   * get a server group by key.
-   * @param serverGroupKey The 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}
    */
-  getServerGroup(serverGroupKey: string): ServerGroup | null {
-    return this.#serverGroups[serverGroupKey]
+  searchBadges(options?: BadgeSearchOptions): Paged<Badge> {
+    return this.#badgeIndex.search(options)
   }
 }