From 002de14a99468937f783ff521994641447c971b5 Mon Sep 17 00:00:00 2001
From: Adrian Klingen <adrian.klingen@deptagency.com>
Date: Tue, 7 May 2024 17:54:29 +0200
Subject: [PATCH 1/2] Add importer cata warning

---
 ui/core/components/importers.ts | 126 +++++++++++++++++++-------------
 1 file changed, 76 insertions(+), 50 deletions(-)

diff --git a/ui/core/components/importers.ts b/ui/core/components/importers.ts
index 94dd646670..23d80f3645 100644
--- a/ui/core/components/importers.ts
+++ b/ui/core/components/importers.ts
@@ -1,27 +1,19 @@
+import { JsonObject } from '@protobuf-ts/runtime';
+
 import { IndividualSimUI } from '../individual_sim_ui';
-import { SimUI } from '../sim_ui';
-import { TypedEvent } from '../typed_event';
-import {
-	Class,
-	EquipmentSpec,
-	ItemSlot,
-	Glyphs,
-	ItemSpec,
-	Profession,
-	Race,
-	Spec,
-} from '../proto/common';
+import { Class, EquipmentSpec, Glyphs, ItemSlot, ItemSpec, Profession, Race, Spec } from '../proto/common';
 import { IndividualSimSettings } from '../proto/ui';
 import { Database } from '../proto_utils/database';
-import { classNames, nameToClass, nameToRace, nameToProfession } from '../proto_utils/names';
+import { classNames, nameToClass, nameToProfession, nameToRace } from '../proto_utils/names';
+import { SimSettingCategories } from '../sim';
+import { SimUI } from '../sim_ui';
 import { classGlyphsConfig, talentSpellIdsToTalentString } from '../talents/factory';
 import { GlyphConfig } from '../talents/glyphs_picker';
-import { BaseModal } from './base_modal';
+import { TypedEvent } from '../typed_event';
 import { buf2hex, getEnumValues } from '../utils';
-import { JsonObject } from '@protobuf-ts/runtime';
-import { SimSettingCategories } from '../sim';
+import { BaseModal } from './base_modal';
 
-declare var pako: any;
+declare let pako: any;
 
 export abstract class Importer extends BaseModal {
 	protected readonly textElem: HTMLTextAreaElement;
@@ -39,13 +31,16 @@ export abstract class Importer extends BaseModal {
 			<textarea spellCheck="false" class="importer-textarea form-control"></textarea>
 		`;
 		this.footer!.innerHTML = `
-			${this.includeFile ? `
+			${
+				this.includeFile
+					? `
 				<label for="${uploadInputId}" class="importer-button btn btn-primary upload-button me-2">
 					<i class="fas fa-file-arrow-up"></i>
 					Upload File
 				</label>
 				<input type="file" id="${uploadInputId}" class="importer-upload-input d-none" hidden>
-			` : ''
+			`
+					: ''
 			}
 			<button class="importer-button btn btn-primary import-button">
 				<i class="fa fa-download"></i>
@@ -65,18 +60,27 @@ export abstract class Importer extends BaseModal {
 		}
 
 		this.importButton = this.rootElem.getElementsByClassName('import-button')[0] as HTMLButtonElement;
-		this.importButton.addEventListener('click', event => {
+		this.importButton.addEventListener('click', async () => {
 			try {
-				this.onImport(this.textElem.value || '');
-			} catch (error) {
-				alert('Import error: ' + error);
+				await this.onImport(this.textElem.value || '');
+			} catch (error: any) {
+				alert(`Import error:
+${error?.message}`);
 			}
 		});
 	}
 
-	abstract onImport(data: string): void
-
-	protected async finishIndividualImport<SpecType extends Spec>(simUI: IndividualSimUI<SpecType>, charClass: Class, race: Race, equipmentSpec: EquipmentSpec, talentsStr: string, glyphs: Glyphs | null, professions: Array<Profession>): Promise<void> {
+	abstract onImport(data: string): Promise<void>;
+
+	protected async finishIndividualImport<SpecType extends Spec>(
+		simUI: IndividualSimUI<SpecType>,
+		charClass: Class,
+		race: Race,
+		equipmentSpec: EquipmentSpec,
+		talentsStr: string,
+		glyphs: Glyphs | null,
+		professions: Array<Profession>,
+	): Promise<void> {
 		const playerClass = simUI.player.getClass();
 		if (charClass != playerClass) {
 			throw new Error(`Wrong Class! Expected ${classNames.get(playerClass)} but found ${classNames.get(charClass)}!`);
@@ -103,10 +107,10 @@ export abstract class Importer extends BaseModal {
 				simUI.player.setTalentsString(eventID, talentsStr);
 			}
 			if (glyphs) {
-				simUI.player.setGlyphs(eventID, glyphs)
+				simUI.player.setGlyphs(eventID, glyphs);
 			}
 			if (professions.length > 0) {
-				simUI.player.setProfessions(eventID, professions)
+				simUI.player.setProfessions(eventID, professions);
 			}
 		});
 
@@ -115,21 +119,22 @@ export abstract class Importer extends BaseModal {
 		if (missingItems.length == 0 && missingEnchants.length == 0) {
 			alert('Import successful!');
 		} else {
-			alert('Import successful, but the following IDs were not found in the sim database:' +
-				(missingItems.length == 0 ? '' : '\n\nItems: ' + missingItems.join(', ')) +
-				(missingEnchants.length == 0 ? '' : '\n\nEnchants: ' + missingEnchants.join(', ')));
+			alert(
+				'Import successful, but the following IDs were not found in the sim database:' +
+					(missingItems.length == 0 ? '' : '\n\nItems: ' + missingItems.join(', ')) +
+					(missingEnchants.length == 0 ? '' : '\n\nEnchants: ' + missingEnchants.join(', ')),
+			);
 		}
 	}
 }
 
 interface UrlParseData {
-	settings: IndividualSimSettings,
-	categories: Array<SimSettingCategories>,
+	settings: IndividualSimSettings;
+	categories: Array<SimSettingCategories>;
 }
 
 // For now this just holds static helpers to match the exporter, so it doesn't extend Importer.
 export class IndividualLinkImporter {
-
 	// Exclude UISettings by default, since most users don't intend to export those.
 	static readonly DEFAULT_CATEGORIES = getEnumValues(SimSettingCategories).filter(c => c != SimSettingCategories.UISettings) as Array<SimSettingCategories>;
 
@@ -148,7 +153,7 @@ export class IndividualLinkImporter {
 		return map;
 	})();
 
-	static tryParseUrlLocation(location: Location): UrlParseData|null {
+	static tryParseUrlLocation(location: Location): UrlParseData | null {
 		let hash = location.hash;
 		if (hash.length <= 1) {
 			return null;
@@ -170,8 +175,7 @@ export class IndividualLinkImporter {
 		if (urlParams.has(IndividualLinkImporter.CATEGORY_PARAM)) {
 			const categoryChars = urlParams.get(IndividualLinkImporter.CATEGORY_PARAM)!.split('');
 			exportCategories = categoryChars
-				.map(char => [...IndividualLinkImporter.CATEGORY_KEYS.entries()]
-				.find(e => e[1] == char))
+				.map(char => [...IndividualLinkImporter.CATEGORY_KEYS.entries()].find(e => e[1] == char))
 				.filter(e => e)
 				.map(e => e![0]);
 		}
@@ -230,10 +234,18 @@ export class Individual80UImporter<SpecType extends Spec> extends Importer {
 		`;
 	}
 
-	onImport(data: string) {
+	async onImport(data: string) {
 		const importJson = JSON.parse(data);
 
 		// Parse all the settings.
+		const charLevel = importJson?.character?.level;
+		const hasReforge = importJson?.items?.some((item: any) => !!item?.reforge);
+		const hasMastery = importJson?.stats?.masteryRating > 0;
+
+		if ((charLevel && charLevel > 80) || hasReforge || hasMastery) {
+			throwCataError();
+		}
+
 		const charClass = nameToClass((importJson?.character?.gameClass as string) || '');
 		if (charClass == Class.ClassUnknown) {
 			throw new Error('Could not parse Class!');
@@ -250,9 +262,9 @@ export class Individual80UImporter<SpecType extends Spec> extends Importer {
 			talentsStr = talentSpellIdsToTalentString(charClass, talentIds);
 		}
 
-		let equipmentSpec = EquipmentSpec.create();
+		const equipmentSpec = EquipmentSpec.create();
 		(importJson.items as Array<any>).forEach(itemJson => {
-			let itemSpec = ItemSpec.create();
+			const itemSpec = ItemSpec.create();
 			itemSpec.id = itemJson.id;
 			if (itemJson.enchant?.id) {
 				itemSpec.enchant = itemJson.enchant.id;
@@ -288,10 +300,15 @@ export class IndividualWowheadGearPlannerImporter<SpecType extends Spec> extends
 		`;
 	}
 
-	onImport(url: string) {
+	async onImport(url: string) {
+		const isCataUrl = url.includes('wowhead.com/cata');
+		if (isCataUrl) {
+			throwCataError();
+		}
+
 		const match = url.match(/www\.wowhead\.com\/wotlk\/gear-planner\/([a-z\-]+)\/([a-z\-]+)\/([a-zA-Z0-9_\-]+)/);
 		if (!match) {
-			throw new Error(`Invalid WCL URL ${url}, must look like "https://www.wowhead.com/wotlk/gear-planner/CLASS/RACE/XXXX"`);
+			throw new Error(`Invalid WowHead URL ${url}, must look like "https://www.wowhead.com/wotlk/gear-planner/CLASS/RACE/XXXX"`);
 		}
 
 		// Parse all the settings.
@@ -307,7 +324,7 @@ export class IndividualWowheadGearPlannerImporter<SpecType extends Spec> extends
 
 		const base64Data = match[3].replaceAll('_', '/').replaceAll('-', '+');
 		//console.log('Base64: ' + base64Data);
-		const data = Uint8Array.from(atob(base64Data), c => c.charCodeAt(0))
+		const data = Uint8Array.from(atob(base64Data), c => c.charCodeAt(0));
 		//console.log('Hex: ' + buf2hex(data));
 
 		// Binary schema
@@ -337,11 +354,10 @@ export class IndividualWowheadGearPlannerImporter<SpecType extends Spec> extends
 		// First byte in glyphs section seems to always be 0x30
 		cur = 1;
 		let hasGlyphs = false;
-		const d = "0123456789abcdefghjkmnpqrstvwxyz";
+		const d = '0123456789abcdefghjkmnpqrstvwxyz';
 		const glyphStr = String.fromCharCode(...glyphBytes);
 		const glyphIds = [0, 0, 0, 0, 0, 0];
 		while (cur < glyphBytes.length) {
-
 			// First byte for each glyph is 0x3z, where z is the glyph position.
 			// 0, 1, 2 are major glyphs, 3, 4, 5 are minor glyphs.
 			const glyphPosition = d.indexOf(glyphStr[cur]);
@@ -349,7 +365,8 @@ export class IndividualWowheadGearPlannerImporter<SpecType extends Spec> extends
 
 			// For some reason, wowhead uses the spell IDs for the glyphs and
 			// applies a ridiculous hashing scheme.
-			const spellId = 0 +
+			const spellId =
+				0 +
 				(d.indexOf(glyphStr[cur + 0]) << 15) +
 				(d.indexOf(glyphStr[cur + 1]) << 10) +
 				(d.indexOf(glyphStr[cur + 2]) << 5) +
@@ -390,7 +407,7 @@ export class IndividualWowheadGearPlannerImporter<SpecType extends Spec> extends
 			cur++;
 
 			const numGems = (gearBytes[cur] & 0b11100000) >> 5;
-			const highid = (gearBytes[cur] & 0b00011111);
+			const highid = gearBytes[cur] & 0b00011111;
 			cur++;
 
 			itemSpec.id = (highid << 16) + (gearBytes[cur] << 8) + gearBytes[cur + 1];
@@ -407,7 +424,7 @@ export class IndividualWowheadGearPlannerImporter<SpecType extends Spec> extends
 
 			for (let gemIdx = 0; gemIdx < numGems; gemIdx++) {
 				const gemPosition = (gearBytes[cur] & 0b11100000) >> 5;
-				const highgemid = (gearBytes[cur] & 0b00011111);
+				const highgemid = gearBytes[cur] & 0b00011111;
 				cur++;
 
 				const gemId = (highgemid << 16) + (gearBytes[cur] << 8) + gearBytes[cur + 1];
@@ -488,13 +505,17 @@ export class IndividualAddonImporter<SpecType extends Spec> extends Importer {
 			throw new Error('Could not parse Race!');
 		}
 
-		const professions = (importJson['professions'] as Array<{ name: string, level: number }>).map(profData => nameToProfession(profData.name));
+		const professions = (importJson['professions'] as Array<{ name: string; level: number }>).map(profData => nameToProfession(profData.name));
 		professions.forEach((prof, i) => {
 			if (prof == Profession.ProfessionUnknown) {
 				throw new Error(`Could not parse profession '${importJson['professions'][i]}'`);
 			}
 		});
 
+		if (importJson['glyphs']['prime']) {
+			throwCataError();
+		}
+
 		const talentsStr = (importJson['talents'] as string) || '';
 		const glyphsConfig = classGlyphsConfig[charClass];
 
@@ -524,12 +545,17 @@ export class IndividualAddonImporter<SpecType extends Spec> extends Importer {
 	}
 }
 
+const throwCataError = () => {
+	throw new Error(`WowSims does not support the Cata Pre-patch.
+Please use: https://wowsims.github.io/cata/ instead`);
+};
+
 function glyphNameToID(glyphName: string, glyphsConfig: Record<number, GlyphConfig>): number {
 	if (!glyphName) {
 		return 0;
 	}
 
-	for (let glyphIDStr in glyphsConfig) {
+	for (const glyphIDStr in glyphsConfig) {
 		if (glyphsConfig[glyphIDStr].name == glyphName) {
 			return parseInt(glyphIDStr);
 		}

From c882a59fbd29bd2beb9284be1eefec727829eda6 Mon Sep 17 00:00:00 2001
From: Adrian Klingen <adrian.klingen@deptagency.com>
Date: Tue, 7 May 2024 18:04:14 +0200
Subject: [PATCH 2/2] Fix TS issue

---
 ui/raid/import_export.ts | 288 +++++++++++++++++++++------------------
 1 file changed, 158 insertions(+), 130 deletions(-)

diff --git a/ui/raid/import_export.ts b/ui/raid/import_export.ts
index eba1aabc48..099287fba9 100644
--- a/ui/raid/import_export.ts
+++ b/ui/raid/import_export.ts
@@ -1,7 +1,8 @@
 import { Exporter } from '../core/components/exporters';
 import { Importer } from '../core/components/importers';
-import { RaidSimSettings } from '../core/proto/ui';
-import { EventID, TypedEvent } from '../core/typed_event';
+import { Encounter } from '../core/encounter';
+import { RaidSimPreset } from '../core/individual_sim_ui';
+import { Player } from '../core/player';
 import { Party as PartyProto, Player as PlayerProto, Raid as RaidProto } from '../core/proto/api';
 import {
 	Class,
@@ -11,30 +12,28 @@ import {
 	ItemSpec,
 	Profession,
 	Race,
-	UnitReference,
 	Spec,
 	Target as TargetProto,
+	UnitReference,
 	UnitReference_Type,
 } from '../core/proto/common';
+import { RaidSimSettings } from '../core/proto/ui';
 import { professionNames, raceNames } from '../core/proto_utils/names';
 import {
-	DruidSpecs,
 	DeathknightSpecs,
-	PriestSpecs,
-	RogueSpecs,
-	SpecOptions,
+	DruidSpecs,
 	getTalentTreePoints,
-	makeDefaultBlessings,
-	raceToFaction,
 	isTankSpec,
+	makeDefaultBlessings,
 	playerToSpec,
+	PriestSpecs,
+	raceToFaction,
+	RogueSpecs,
+	SpecOptions,
 } from '../core/proto_utils/utils';
 import { MAX_NUM_PARTIES } from '../core/raid';
-import { RaidSimPreset } from '../core/individual_sim_ui';
-import { Player } from '../core/player';
-import { Encounter } from '../core/encounter';
+import { EventID, TypedEvent } from '../core/typed_event';
 import { bucket, distinct } from '../core/utils';
-
 import { playerPresets } from './presets';
 import { RaidSimUI } from './raid_sim_ui';
 
@@ -54,7 +53,7 @@ export class RaidJsonImporter extends Importer {
 		`;
 	}
 
-	onImport(data: string) {
+	async onImport(data: string) {
 		const settings = RaidSimSettings.fromJsonString(data, { ignoreUnknownFields: true });
 		this.simUI.fromProto(TypedEvent.nextEventID(), settings);
 		this.close();
@@ -65,7 +64,7 @@ export class RaidJsonExporter extends Exporter {
 	private readonly simUI: RaidSimUI;
 
 	constructor(parent: HTMLElement, simUI: RaidSimUI) {
-		super(parent, simUI, {title: 'JSON Export', allowDownload: true});
+		super(parent, simUI, { title: 'JSON Export', allowDownload: true });
 		this.simUI = simUI;
 		this.init();
 	}
@@ -76,8 +75,7 @@ export class RaidJsonExporter extends Exporter {
 }
 
 export class RaidWCLImporter extends Importer {
-
-	private queryCounter: number = 0;
+	private queryCounter = 0;
 
 	private readonly simUI: RaidSimUI;
 	constructor(parent: HTMLElement, simUI: RaidSimUI) {
@@ -121,18 +119,18 @@ export class RaidWCLImporter extends Importer {
 		`;
 	}
 
-	private token: string = '';
+	private token = '';
 	private async getWCLBearerToken(): Promise<string> {
 		if (this.token == '') {
 			const response = await fetch('https://classic.warcraftlogs.com/oauth/token', {
-				'method': 'POST',
-				'headers': {
-					'Authorization': 'Basic ' + btoa('963d31c8-7efa-4dde-87cf-1b254a8a2f8c:lRJVhujEEnF96xfUoxVHSpnqKN9v8bTqGEjutsO3'),
+				method: 'POST',
+				headers: {
+					Authorization: 'Basic ' + btoa('963d31c8-7efa-4dde-87cf-1b254a8a2f8c:lRJVhujEEnF96xfUoxVHSpnqKN9v8bTqGEjutsO3'),
 				},
 				body: new URLSearchParams({
-					'grant_type': 'client_credentials',
+					grant_type: 'client_credentials',
 				}),
-			})
+			});
 			const json = await response.json();
 			this.token = json.access_token;
 		}
@@ -143,8 +141,8 @@ export class RaidWCLImporter extends Importer {
 		const token = await this.getWCLBearerToken();
 		const headers = {
 			'Content-Type': 'application/json',
-			'Authorization': `Bearer ${token}`,
-			'Accept': 'application/json',
+			Authorization: `Bearer ${token}`,
+			Accept: 'application/json',
 		};
 
 		const queryURL = `https://classic.warcraftlogs.com/api/v2/client?query=${query}`;
@@ -152,8 +150,8 @@ export class RaidWCLImporter extends Importer {
 
 		// Query WCL
 		const res = await fetch(encodeURI(queryURL), {
-			'method': 'GET',
-			'headers': headers,
+			method: 'GET',
+			headers: headers,
 		});
 
 		const result = await res.json();
@@ -175,7 +173,7 @@ export class RaidWCLImporter extends Importer {
 		const urlData = {
 			reportID: match[1],
 			fightID: '',
-		}
+		};
 
 		// If the URL has a Fight ID in it, use it
 		if (match[2] && match[3] && match[3] != 'last') {
@@ -196,7 +194,7 @@ export class RaidWCLImporter extends Importer {
 			const fights = fightData.data.reportData.report.fights;
 
 			if (match[3] == 'last') {
-				urlData.fightID = String(fights[fights.length - 1].id)
+				urlData.fightID = String(fights[fights.length - 1].id);
 			} else {
 				// Default to using the first Fight
 				urlData.fightID = String(fights[0].id);
@@ -227,7 +225,7 @@ export class RaidWCLImporter extends Importer {
 			console.error(error);
 			alert('Failed import from WCL: ' + error);
 		}
-		this.importButton.disabled = false
+		this.importButton.disabled = false;
 		this.rootElem.style.removeProperty('cursor');
 	}
 
@@ -255,14 +253,23 @@ export class RaidWCLImporter extends Importer {
 						startTime, endTime, id, name
 					}
 
-					reportCastEvents: events(dataType:Casts, endTime: 99999999, filterExpression: "${[racialSpells, professionSpells].flat().map(spell => spell.id).map(id => `ability.id = ${id}`).join(' OR ')
-			}", limit: 10000) { data }
+					reportCastEvents: events(dataType:Casts, endTime: 99999999, filterExpression: "${[racialSpells, professionSpells]
+						.flat()
+						.map(spell => spell.id)
+						.map(id => `ability.id = ${id}`)
+						.join(' OR ')}", limit: 10000) { data }
 
-					fightCastEvents: events(fightIDs: [${urlData.fightID}], dataType:Casts, filterExpression: "${[externalCDSpells].flat().map(spell => spell.id).map(id => `ability.id = ${id}`).join(' OR ')
-			}", limit: 10000) { data }
+					fightCastEvents: events(fightIDs: [${urlData.fightID}], dataType:Casts, filterExpression: "${[externalCDSpells]
+						.flat()
+						.map(spell => spell.id)
+						.map(id => `ability.id = ${id}`)
+						.join(' OR ')}", limit: 10000) { data }
 
-					fightHealEvents: events(fightIDs: [${urlData.fightID}], dataType:Healing, filterExpression: "${[samePartyHealingSpells, otherPartyHealingSpells].flat().map(spell => spell.id).map(id => `ability.id = ${id}`).join(' OR ')
-			}", limit: 10000) { data }
+					fightHealEvents: events(fightIDs: [${urlData.fightID}], dataType:Healing, filterExpression: "${[samePartyHealingSpells, otherPartyHealingSpells]
+						.flat()
+						.map(spell => spell.id)
+						.map(id => `ability.id = ${id}`)
+						.join(' OR ')}", limit: 10000) { data }
 
 					manaTideTotem: events(fightIDs: [${urlData.fightID}], dataType:Resources, filterExpression: "ability.id = 39609", limit: 100) { data }
 				}
@@ -466,7 +473,7 @@ export class RaidWCLImporter extends Importer {
 	}
 
 	private getEncounterProto(wclData: any): EncounterProto {
-		const fight: { startTime: number, endTime: number, id: number, name: string } = wclData.fights[0];
+		const fight: { startTime: number; endTime: number; id: number; name: string } = wclData.fights[0];
 
 		const encounter = EncounterProto.create({
 			duration: (fight.endTime - fight.startTime) / 1000,
@@ -474,7 +481,7 @@ export class RaidWCLImporter extends Importer {
 		});
 
 		// Use the preset encounter if it exists.
-		let closestEncounterPreset = this.simUI.sim.db.getAllPresetEncounters().find(enc => enc.path.includes(fight.name));
+		const closestEncounterPreset = this.simUI.sim.db.getAllPresetEncounters().find(enc => enc.path.includes(fight.name));
 		if (closestEncounterPreset && closestEncounterPreset.targets.length) {
 			closestEncounterPreset.targets
 				.map(mob => mob.target as TargetProto)
@@ -492,22 +499,23 @@ export class RaidWCLImporter extends Importer {
 
 	private getRaidProto(wclPlayers: WCLSimPlayer[]): RaidProto {
 		const raid = RaidProto.create({
-			parties: [...new Array(MAX_NUM_PARTIES).keys()].map(_party => PartyProto.create({
-				players: [...new Array(5).keys()].map(_player => PlayerProto.create()),
-			})),
+			parties: [...new Array(MAX_NUM_PARTIES).keys()].map(_party =>
+				PartyProto.create({
+					players: [...new Array(5).keys()].map(_player => PlayerProto.create()),
+				}),
+			),
 		});
 
-		wclPlayers
-			.forEach(player => {
-				const positionInParty = player.raidIndex % 5;
-				const partyIdx = (player.raidIndex - positionInParty) / 5;
-				const playerProto = player.player.toProto();
-				raid.parties[partyIdx].players[positionInParty] = playerProto;
+		wclPlayers.forEach(player => {
+			const positionInParty = player.raidIndex % 5;
+			const partyIdx = (player.raidIndex - positionInParty) / 5;
+			const playerProto = player.player.toProto();
+			raid.parties[partyIdx].players[positionInParty] = playerProto;
 
-				if (isTankSpec(playerToSpec(playerProto))) {
-					raid.tanks.push(player.toUnitReference());
-				}
-			});
+			if (isTankSpec(playerToSpec(playerProto))) {
+				raid.tanks.push(player.toUnitReference());
+			}
+		});
 
 		return raid;
 	}
@@ -518,7 +526,7 @@ class WCLSimPlayer {
 	public readonly id: number;
 	public readonly name: string;
 	public readonly type: string;
-	public raidIndex: number = -1;
+	public raidIndex = -1;
 
 	private readonly simUI: RaidSimUI;
 	private readonly fullType: string;
@@ -552,11 +560,14 @@ class WCLSimPlayer {
 
 		this.preset = WCLSimPlayer.getMatchingPreset(foundSpec, data.talents);
 		if (this.preset === undefined) {
-			throw new Error('Could not find matching preset: ' + JSON.stringify({
-				'name': this.name,
-				'type': this.fullType,
-				'talents': data.talents,
-			}).toString());
+			throw new Error(
+				'Could not find matching preset: ' +
+					JSON.stringify({
+						name: this.name,
+						type: this.fullType,
+						talents: data.talents,
+					}).toString(),
+			);
 		}
 
 		// Apply preset defaults.
@@ -569,17 +580,24 @@ class WCLSimPlayer {
 
 		// Apply settings from report data.
 		this.player.setName(eventID, data.name);
-		this.player.setGear(eventID, simUI.sim.db.lookupEquipmentSpec(EquipmentSpec.create({
-			items: data.gear.map(gear => ItemSpec.create({
-				id: gear.id,
-				enchant: gear.permanentEnchant,
-				gems: gear.gems ? gear.gems.map(gemInfo => gemInfo.id) : [],
-			})),
-		})));
+		this.player.setGear(
+			eventID,
+			simUI.sim.db.lookupEquipmentSpec(
+				EquipmentSpec.create({
+					items: data.gear.map(gear =>
+						ItemSpec.create({
+							id: gear.id,
+							enchant: gear.permanentEnchant,
+							gems: gear.gems ? gear.gems.map(gemInfo => gemInfo.id) : [],
+						}),
+					),
+				}),
+			),
+		);
 	}
 
 	private static getMatchingPreset(spec: Spec, talents: wclTalents[]): RaidSimPreset<Spec> {
-		const matchingPresets = playerPresets.filter((preset) => preset.spec == spec);
+		const matchingPresets = playerPresets.filter(preset => preset.spec == spec);
 		let presetIdx = 0;
 
 		if (matchingPresets && matchingPresets.length > 1) {
@@ -588,7 +606,7 @@ class WCLSimPlayer {
 			matchingPresets.forEach((preset, i) => {
 				const presetTalents = getTalentTreePoints(preset.talents.talentsString);
 				// Diff the distance to the preset.
-				const newDistance = presetTalents.reduce((acc, v, i) => acc += Math.abs(talents[i]?.guid - presetTalents[i]), 0);
+				const newDistance = presetTalents.reduce((acc, v, i) => (acc += Math.abs(talents[i]?.guid - presetTalents[i])), 0);
 
 				// If this is the best distance, assign this preset.
 				if (newDistance < distance) {
@@ -617,50 +635,50 @@ class WCLSimPlayer {
 }
 
 const fullTypeToSpec: Record<string, Spec> = {
-	'DeathKnightBlood': Spec.SpecTankDeathknight,
-	'DeathKnightLichborne': Spec.SpecTankDeathknight,
-	'DeathKnightRuneblade': Spec.SpecDeathknight,
-	'DeathKnightBloodDPS': Spec.SpecDeathknight,
-	'DeathKnightFrost': Spec.SpecDeathknight,
-	'DeathKnightUnholy': Spec.SpecDeathknight,
-	'DruidBalance': Spec.SpecBalanceDruid,
-	'DruidFeral': Spec.SpecFeralDruid,
-	'DruidWarden': Spec.SpecFeralTankDruid,
-	'DruidGuardian': Spec.SpecFeralTankDruid,
-	'DruidRestoration': Spec.SpecRestorationDruid,
-	'HunterBeastMastery': Spec.SpecHunter,
-	'HunterSurvival': Spec.SpecHunter,
-	'HunterMarksmanship': Spec.SpecHunter,
-	'MageArcane': Spec.SpecMage,
-	'MageFire': Spec.SpecMage,
-	'MageFrost': Spec.SpecMage,
-	'PaladinHoly': Spec.SpecHolyPaladin,
-	'PaladinJusticar': Spec.SpecProtectionPaladin,
-	'PaladinProtection': Spec.SpecProtectionPaladin,
-	'PaladinRetribution': Spec.SpecRetributionPaladin,
-	'PriestHoly': Spec.SpecHealingPriest,
-	'PriestDiscipline': Spec.SpecHealingPriest,
-	'PriestShadow': Spec.SpecShadowPriest,
-	'PriestSmite': Spec.SpecSmitePriest,
-	'RogueAssassination': Spec.SpecRogue,
-	'RogueCombat': Spec.SpecRogue,
-	'RogueSubtlety': Spec.SpecRogue,
-	'ShamanElemental': Spec.SpecElementalShaman,
-	'ShamanEnhancement': Spec.SpecEnhancementShaman,
-	'ShamanRestoration': Spec.SpecRestorationShaman,
-	'WarlockDestruction': Spec.SpecWarlock,
-	'WarlockAffliction': Spec.SpecWarlock,
-	'WarlockDemonology': Spec.SpecWarlock,
-	'WarriorArms': Spec.SpecWarrior,
-	'WarriorFury': Spec.SpecWarrior,
-	'WarriorChampion': Spec.SpecWarrior,
-	'WarriorWarrior': Spec.SpecWarrior,
-	'WarriorGladiator': Spec.SpecWarrior,
-	'WarriorProtection': Spec.SpecProtectionWarrior,
+	DeathKnightBlood: Spec.SpecTankDeathknight,
+	DeathKnightLichborne: Spec.SpecTankDeathknight,
+	DeathKnightRuneblade: Spec.SpecDeathknight,
+	DeathKnightBloodDPS: Spec.SpecDeathknight,
+	DeathKnightFrost: Spec.SpecDeathknight,
+	DeathKnightUnholy: Spec.SpecDeathknight,
+	DruidBalance: Spec.SpecBalanceDruid,
+	DruidFeral: Spec.SpecFeralDruid,
+	DruidWarden: Spec.SpecFeralTankDruid,
+	DruidGuardian: Spec.SpecFeralTankDruid,
+	DruidRestoration: Spec.SpecRestorationDruid,
+	HunterBeastMastery: Spec.SpecHunter,
+	HunterSurvival: Spec.SpecHunter,
+	HunterMarksmanship: Spec.SpecHunter,
+	MageArcane: Spec.SpecMage,
+	MageFire: Spec.SpecMage,
+	MageFrost: Spec.SpecMage,
+	PaladinHoly: Spec.SpecHolyPaladin,
+	PaladinJusticar: Spec.SpecProtectionPaladin,
+	PaladinProtection: Spec.SpecProtectionPaladin,
+	PaladinRetribution: Spec.SpecRetributionPaladin,
+	PriestHoly: Spec.SpecHealingPriest,
+	PriestDiscipline: Spec.SpecHealingPriest,
+	PriestShadow: Spec.SpecShadowPriest,
+	PriestSmite: Spec.SpecSmitePriest,
+	RogueAssassination: Spec.SpecRogue,
+	RogueCombat: Spec.SpecRogue,
+	RogueSubtlety: Spec.SpecRogue,
+	ShamanElemental: Spec.SpecElementalShaman,
+	ShamanEnhancement: Spec.SpecEnhancementShaman,
+	ShamanRestoration: Spec.SpecRestorationShaman,
+	WarlockDestruction: Spec.SpecWarlock,
+	WarlockAffliction: Spec.SpecWarlock,
+	WarlockDemonology: Spec.SpecWarlock,
+	WarriorArms: Spec.SpecWarrior,
+	WarriorFury: Spec.SpecWarrior,
+	WarriorChampion: Spec.SpecWarrior,
+	WarriorWarrior: Spec.SpecWarrior,
+	WarriorGladiator: Spec.SpecWarrior,
+	WarriorProtection: Spec.SpecProtectionWarrior,
 };
 
 // Spells which imply a specific Race.
-const racialSpells: Array<{ id: number, name: string, race: Race }> = [
+const racialSpells: Array<{ id: number; name: string; race: Race }> = [
 	{ id: 25046, name: 'Arcane Torrent (Energy)', race: Race.RaceBloodElf },
 	{ id: 28730, name: 'Arcane Torrent (Mana)', race: Race.RaceBloodElf },
 	{ id: 50613, name: 'Arcane Torrent (Runic Power)', race: Race.RaceBloodElf },
@@ -676,44 +694,56 @@ const racialSpells: Array<{ id: number, name: string, race: Race }> = [
 ];
 
 // Spells which imply a specific Profession.
-const professionSpells: Array<{ id: number, name: string, profession: Profession }> = [
+const professionSpells: Array<{ id: number; name: string; profession: Profession }> = [
 	{ id: 55503, name: 'Lifeblood', profession: Profession.Herbalism },
 	{ id: 50305, name: 'Skinning', profession: Profession.Skinning },
 ];
 
-const externalCDSpells: Array<{ id: number, name: string, class: Class, applyFunc: (player: Player<any>, raidTarget: UnitReference) => SpecOptions<any> }> = [
+const externalCDSpells: Array<{ id: number; name: string; class: Class; applyFunc: (player: Player<any>, raidTarget: UnitReference) => SpecOptions<any> }> = [
 	{
-		id: 29166, name: 'Innervate', class: Class.ClassDruid, applyFunc: (player: Player<any>, raidTarget: UnitReference) => {
+		id: 29166,
+		name: 'Innervate',
+		class: Class.ClassDruid,
+		applyFunc: (player: Player<any>, raidTarget: UnitReference) => {
 			const options = player.getSpecOptions() as SpecOptions<DruidSpecs>;
 			options.innervateTarget = raidTarget;
 			return options;
-		}
+		},
 	},
 	{
-		id: 10060, name: 'Power Infusion', class: Class.ClassPriest, applyFunc: (player: Player<any>, raidTarget: UnitReference) => {
+		id: 10060,
+		name: 'Power Infusion',
+		class: Class.ClassPriest,
+		applyFunc: (player: Player<any>, raidTarget: UnitReference) => {
 			const options = player.getSpecOptions() as SpecOptions<PriestSpecs>;
 			options.powerInfusionTarget = raidTarget;
 			return options;
-		}
+		},
 	},
 	{
-		id: 57933, name: 'Tricks of the Trade', class: Class.ClassRogue, applyFunc: (player: Player<any>, raidTarget: UnitReference) => {
+		id: 57933,
+		name: 'Tricks of the Trade',
+		class: Class.ClassRogue,
+		applyFunc: (player: Player<any>, raidTarget: UnitReference) => {
 			const options = player.getSpecOptions() as SpecOptions<RogueSpecs>;
 			options.tricksOfTheTradeTarget = raidTarget;
 			return options;
-		}
+		},
 	},
 	{
-		id: 49016, name: 'Unholy Frenzy', class: Class.ClassDeathknight, applyFunc: (player: Player<any>, raidTarget: UnitReference) => {
+		id: 49016,
+		name: 'Unholy Frenzy',
+		class: Class.ClassDeathknight,
+		applyFunc: (player: Player<any>, raidTarget: UnitReference) => {
 			const options = player.getSpecOptions() as SpecOptions<DeathknightSpecs>;
 			options.unholyFrenzyTarget = raidTarget;
 			return options;
-		}
+		},
 	},
 ];
 
 // Healing spells which only affect the caster's party.
-const samePartyHealingSpells: Array<{ id: number, name: string }> = [
+const samePartyHealingSpells: Array<{ id: number; name: string }> = [
 	{ id: 52042, name: 'Healing Stream Totem' },
 	{ id: 48076, name: 'Holy Nova' },
 	{ id: 48445, name: 'Tranquility' },
@@ -721,17 +751,15 @@ const samePartyHealingSpells: Array<{ id: number, name: string }> = [
 ];
 
 // Healing spells which only affect a single party, but not necessarily the caster's party.
-const otherPartyHealingSpells: Array<{ id: number, name: string }> = [
-	{ id: 48072, name: 'Prayer of Healing' },
-];
+const otherPartyHealingSpells: Array<{ id: number; name: string }> = [{ id: 48072, name: 'Prayer of Healing' }];
 
 interface wclUrlData {
-	reportID: string,
-	fightID: string,
+	reportID: string;
+	fightID: string;
 }
 
 interface wclCastEvent {
-	type: 'cast',
+	type: 'cast';
 	timestamp: number;
 	sourceID: number;
 	targetID: number;
@@ -740,7 +768,7 @@ interface wclCastEvent {
 }
 
 interface wclHealEvent {
-	type: 'heal',
+	type: 'heal';
 	timestamp: number;
 	sourceID: number;
 	targetID: number;
@@ -760,9 +788,9 @@ interface wclCombatantInfoEvent {
 }
 
 interface wclRateLimitData {
-	limitPerHour: number,
-	pointsSpentThisHour: number,
-	pointsResetIn: number
+	limitPerHour: number;
+	pointsSpentThisHour: number;
+	pointsResetIn: number;
 }
 
 // Typed interface for WCL talents
@@ -821,7 +849,7 @@ interface _wclAura {
 	totalUptime: number;
 	totalUses: number;
 	bands: {
-		startTime: number,
-		endTime: number,
+		startTime: number;
+		endTime: number;
 	}[];
 }