Intro to Scripts

source.name = "Kihra"

pinMatchesFightEvent = (event, fight) => {
    return event.source.name == "Kihra";
}

declare global {
  /**
   * The current API version. Used to see if a report component is out of date.
   */
  const apiVersion: string;

  /**
   * The current report group.
   */
  const reportGroup: RpgLogs.ReportGroup;

  /**
   * The translated language. Null if no language is set. This is only set if the user is forcing all logs to be translated to a specific language.
   */
  const translatedLanguage: string | null;

  /**
   * Whether or not player names should be anonymized. You will not have access to the real names of the players if this is set.
   */
  const anonymizePlayerNames: boolean;

  /**
   * The filters in effect for the fight.
   */
  const fightFilters: RpgLogs.FightFilters;
}

reportGroup.reports[0] // Get the first report in the group.

type FightFilters = {
    /**
     * The start time of the filter. Fights that end before this start time will not be included.
     */
    startTime: number;

    /**
     * The end time of the filter. Fights that begin after this end time will not be included.
     */
    endTime: number;

    /**
     * The encounter to filter to. 0 if all fights should be included. If set to a specific boss, only pulls of that boss will be matched.
     */
    encounterId: number;

    /**
     * The kill type. Valid values include "all", "encounters", "trash", "kills", and "wipes".
     */
    killType: string;

    /**
     * The difficulty to filter to. If set to a value other than 0, only fights matching the specified difficulty will be matched.
     */
    difficulty: number;

    /**
     * A set of specific fight ids to match on. Exists on top of the other filters, so only fights in this list can be matched.
     */
    fightIds: number[] | null;

    /**
     * Test if a fight matches these filters.
     * @param fight - The fight to check.
     * @returns Whether or not the fight matches the filters.
     */
    matches(fight: Fight): boolean;
  };

interface ReportGroup {
    /**
     * The version of the parser that was used to parse the log file for this report.
     */
    logVersion: number;

    /**
     * The game version of reports in the report group. For World of Warcraft, 1 = Retail, 2 = Vanilla, 3 = TBC, and 4 = Wrath.
     * For other games, this will just be 1.
     */
    gameVersion: number;

    /**
     * The language of the reports in the report group. Null if no language could be determined.
     */
    language: string | null;

    /**
     * The set of actors that were seen in this report group. This includes all players, pets and NPCs.
     */
    actors: Actor[];

    /**
     * The set of abilities that were seen in this report group.
     */
    abilities: Ability[];

    /**
     * All of the fights in the report group.
     */
    allFights: Fight[];

    /**
     * The set of fights that matches the report UI's filters for start time, end time, what encounters
     * to allow, and whether or not to show trash, kills or wipes only.
     */
    fights: Fight[];

    /**
     * All the reports loaded in this group.
     */
    reports: Report[];
  }

interface Report {
    /**
     * The version of the parser that was used to parse the log file for this report.
     */
    logVersion: number;

    /**
     * The game version of the report. For World of Warcraft, 1 = Retail, 2 = Vanilla, 3 = TBC, and 4 = Wrath.
     * For other games, this will just be 1.
     */
    gameVersion: number;

    /**
     * The language of the report. Null if no language could be determined.
     */
    language: string | null;

    /**
     * The number of segments used by the report. Will increase as more fights get uploaded.
     */
    segments: number;

    /**
     * The set of actors that were seen in this report. This includes all players, pets and NPCs.
     */
    actors: Actor[];

    /**
     * The set of abilities that were seen in this report.
     */
    abilities: Ability[];

    /**
     * All of the fights in the report.
     */
    fights: Fight[];

    /**
     * All complete raids in the report. These include entire runs of instances in situations where those
     * runs are supported (e.g., Serpentshrine Cavern, Sanctum of Domination, Naxxramas, etc.)
     */
    completeRaids: CompleteRaid[];
}

interface Fight {
    /**
     * The id of the fight within its containing report group.
     */
    id: number;

    /**
     * The id of the fight within its containing report.
     */
    idInReport: number;

    /**
     * The report that the fight belongs to.
     */
    report: Report;

    /**
     * The encounter id of the fight. Trash fights just have an encounter id of 0.
     */
    encounterId: number;

    /**
     * The encounter size (number of players).
     */
    size: number;

    /**
     * The encounter difficulty.
     */
    difficulty: number;

    /**
     * Whether or not a fight with an encounter id was a kill.
     */
    isKill: boolean;

    /**
     * A localized name for the fight. For encounters, it will be the encounter name, and for trash fights, it will
     * be the name of the NPC with the most hit points that was involved in the fight.
     */
    name: string;

    /**
     * The start time of the fight. This is an offset relative to the start of the report, not an absolute time.
     * This offset is in milliseconds.
     */
    startTime: number;

    /**
     * The end time of the fight. This is an offset relative to the start of the report, not an absolute time.
     * This offset is in milliseconds.
     */
    endTime: number;

    /**
     * Combatant info events. These are cached, so this is faster than trying to find them on your own.
     */
    combatantInfoEvents: AnyCombatantInfoEvent[];

    /**
     * Death events of friendly players respecting the user's filters. These are cached, so this is faster than trying to find them on your own.
     */
    friendlyPlayerDeathEvents: DeathEvent[];

    /**
     * Death events of all friendly players. These are cached, so this is faster than trying to find them on your own.
     */
    allFriendlyPlayerDeathEvents: DeathEvent[];

    /**
     * Death events of enemies respecting the user's filters. These are cached, so this is faster than trying to find them on your own.
     * For PvE content, the deaths are limited to NPCs. For supported PvP content, the deaths are of enemy players.
     */
    enemyDeathEvents: DeathEvent[];

    /**
     * Death events of enemies. These are cached, so this is faster than trying to find them on your own.
     * For PvE content, the deaths are limited to NPCs. For supported PvP content, the deaths are of enemy players.
     */
    allEnemyDeathEvents: DeathEvent[];

    /**
     * All of the events in this fight.
     */
    allEvents: AnyEvent[];

    /**
     * The events of the fight respecting the user's filters.
     */
    events: AnyEvent[];

    /**
     * This method will obtain a cached subset of events matching the specified category and disposition.
     * The events will be filtered to the user's current event filters (e.g., phase, death cutoff, start/end time).
     * @param category - The category of events to fetch
     * @param disposition  - The disposition of the actors to check. A value of "neutral" will be treated like "enemy".
     * @returns The cached event set. Use this method to quickly retrieve a subset of events.
     */
    eventsByCategoryAndDisposition(
      category: EventCategory,
      disposition: ActorDisposition
    ): AnyEvent[];

    /**
     * This method will obtain a cached subset of events matching the specified category and disposition.
     * @param category - The category of events to fetch
     * @param disposition  - The disposition of the actors to check. A value of "neutral" will be treated like "enemy".
     * @returns The cached event set. Use this method to quickly retrieve a subset of events.
     */
    allEventsByCategoryAndDisposition(
      category: EventCategory,
      disposition: ActorDisposition
    ): AnyEvent[];

    /**
     * Helper function to obtain the phase an event occurs in.
     * @param event - The event whose timestamp will be checked against the phase transitions.
     * @returns The phase the event occurs in, or null if the fight has no phases.
     */
    phaseForEvent(event: AnyEvent): number | null;

    /**
     * The phase transitions. Each entry in the array contains all of the start/end bands for that specific phase.
     */
    phaseTransitions: Array<Array<Band>> | null;

    /**
     * For fights where downtime is supported and used to shrink the total time over which damage dealt is considered,
     * this will contain an array of the start/end bands for every chunk of downtime.
     */
    downtimeTransitions: Array<Band> | null;

    /**
     * Whether or not an actor is a friendly participant.
     * @param actor - The actor to check.
     * @returns Whether or not the actor is a friendly participant
     */
    isFriendlyParticipant(actor: Actor): boolean;

    /**
     * Whether or not an actor is an enemy participant.
     * @param actor - The actor to check.
     * @returns Whether or not the actor is an enemy participant
     */
    isEnemyParticipant(actor: Actor): boolean;

    /**
     * All the friendly participants in the fight.
     */
    friendlyParticipants: Array<Actor>;

    /**
     * All the enemy participants in the fight.
     */
    enemyParticipants: Array<Actor>;

    /**
     * The maps used by the fight.
     */
    maps: Map;

    /**
     * The zone used by the fight.
     */
    zone: Zone | null;

    /**
     * The bounding box for the fight in coordinates.
     */
    minX: number;
    maxX: number;
    minY: number;
    maxY: number;

    /**
     * For dungeons, individual pulls are stored and can be accessed.
     */
    dungeonPulls: Array<DungeonPull>;

    /**
     * The world markers used by this fight.
     */
    worldMarkers: Array<WorldMarker>;

    /**
     * Whether or not this event should be excluded from damage rankings.
     * @param event - The event to check.
     * @returns Whether or not the event counts as part of damage done ranks.
     */
    isEventExcludedFromDamageRankings(event: AnyEvent): boolean;

    /**
     * Get the set of damage events and amounts that represent the damage healed by this event.
     * The amount are distinct from the events themselves so that you can see when a heal only partially
     * healed some of the damage.
     * @param event - The event to check
     * @returns - An array of events and the amount of damage healed for each event.
     */
    damageEventsForHealingEvent(event: AnyEvent): Array<EventAndAmount> | null;

    /**
     * Get the set of healing events and amounts that represent the heals that were done for this damage.
     * The amount are distinct from the events themselves so that you can see when a heal only partially
     * healed some of the damage.
     * @param event - The event to check
     * @returns - An array of events and the amount of damage healed for each event.
     */
    healingEventsForDamageEvent(event: AnyEvent): Array<EventAndAmount> | null;

    /**
     * The item level for a given actor.
     * @param actor - The player to fetch the item level for.
     * @returns - The item level of the actor
     */
    itemLevelForPlayer(actor: Actor): number;

    /**
     * The spec for a given actor.
     * @param actor - The player to fetch the spec for.
     * @returns - The spec of the actor
     */
    specForPlayer(actor: Actor): number;

    /**
     * The instance count for a given actor.
     * @param actor - The actor to fetch the group count for.
     * @returns - The instance count of the actor
     */
    instanceCountForNpc(actor: Actor): number;

    /**
     * The instance group count for a given actor.
     * @param actor - The actor to fetch the group count for.
     * @returns - The group count of the actor
     */
    instanceGroupCountForNpc(actor: Actor): number;
}