303 lines
11 KiB
TypeScript
303 lines
11 KiB
TypeScript
// SPDX-FileCopyrightText: 2021 Johannes Loher
|
|
// SPDX-FileCopyrightText: 2021 Oliver Rümpelein
|
|
// SPDX-FileCopyrightText: 2021 Gesina Schwalbe
|
|
// SPDX-FileCopyrightText: 2021 Siegfried Krug
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
import { ModifiableDataBaseTotal } from "../../common/common-data";
|
|
import { DS4 } from "../../config";
|
|
import { getCanvas, getGame } from "../../helpers";
|
|
import { DS4Item } from "../../item/item";
|
|
import { DS4Settings, getDS4Settings } from "../../settings";
|
|
import notifications from "../../ui/notifications";
|
|
import { isCheck } from "../actor-data-properties";
|
|
|
|
/**
|
|
* The base Sheet class for all DS4 Actors
|
|
*/
|
|
export class DS4ActorSheet extends ActorSheet<ActorSheet.Options, DS4ActorSheetData> {
|
|
/** @override */
|
|
static get defaultOptions(): ActorSheet.Options {
|
|
return foundry.utils.mergeObject(super.defaultOptions, {
|
|
classes: ["ds4", "sheet", "actor"],
|
|
height: 620,
|
|
scrollY: [
|
|
".values",
|
|
".inventory",
|
|
".spells",
|
|
".abilities",
|
|
".profile",
|
|
".biography",
|
|
".special-creature-abilities",
|
|
],
|
|
tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "values" }],
|
|
dragDrop: [
|
|
{ dragSelector: ".item-list .item", dropSelector: null },
|
|
{ dragSelector: ".ds4-check", dropSelector: null },
|
|
],
|
|
width: 650,
|
|
});
|
|
}
|
|
|
|
/** @override */
|
|
get template(): string {
|
|
const basePath = "systems/ds4/templates/sheets/actor";
|
|
return `${basePath}/${this.actor.data.type}-sheet.hbs`;
|
|
}
|
|
|
|
/**
|
|
* This method returns the data for the template of the actor sheet.
|
|
* It explicitly adds the items of the object sorted by type in the
|
|
* object itemsByType.
|
|
* @returns The data fed to the template of the actor sheet
|
|
*/
|
|
async getData(): Promise<DS4ActorSheetData> {
|
|
const itemsByType = Object.fromEntries(
|
|
Object.entries(this.actor.itemTypes).map(([itemType, items]) => {
|
|
return [itemType, items.map((item) => item.data).sort((a, b) => (a.sort || 0) - (b.sort || 0))];
|
|
}),
|
|
);
|
|
const data = {
|
|
...this.addTooltipsToData(await super.getData()),
|
|
// Add the localization config to the data:
|
|
config: DS4,
|
|
// Add the items explicitly sorted by type to the data:
|
|
itemsByType,
|
|
settings: getDS4Settings(),
|
|
};
|
|
return data;
|
|
}
|
|
|
|
protected addTooltipsToData(data: ActorSheet.Data): ActorSheet.Data {
|
|
const valueGroups = [data.data.data.attributes, data.data.data.traits, data.data.data.combatValues];
|
|
|
|
valueGroups.forEach((valueGroup) => {
|
|
Object.values(valueGroup).forEach((attribute: ModifiableDataBaseTotal<number> & { tooltip?: string }) => {
|
|
attribute.tooltip = this.getTooltipForValue(attribute);
|
|
});
|
|
});
|
|
return data;
|
|
}
|
|
|
|
protected getTooltipForValue(value: ModifiableDataBaseTotal<number>): string {
|
|
return `${value.base} (${getGame().i18n.localize("DS4.TooltipBaseValue")}) + ${
|
|
value.mod
|
|
} (${getGame().i18n.localize("DS4.TooltipModifier")}) ➞ ${getGame().i18n.localize("DS4.TooltipEffects")} ➞ ${
|
|
value.total
|
|
}`;
|
|
}
|
|
|
|
/** @override */
|
|
activateListeners(html: JQuery): void {
|
|
super.activateListeners(html);
|
|
|
|
// Everything below here is only needed if the sheet is editable
|
|
if (!this.options.editable) return;
|
|
|
|
// Add Inventory Item
|
|
html.find(".item-create").on("click", this.onItemCreate.bind(this));
|
|
|
|
// Update Inventory Item
|
|
html.find(".item-edit").on("click", (ev) => {
|
|
const li = $(ev.currentTarget).parents(".item");
|
|
const id = li.data("itemId");
|
|
const item = this.actor.items.get(id);
|
|
if (!item) {
|
|
throw new Error(getGame().i18n.format("DS4.ErrorActorDoesNotHaveItem", { id, actor: this.actor.name }));
|
|
}
|
|
if (!item.sheet) {
|
|
throw new Error(getGame().i18n.localize("DS4.ErrorUnexpectedError"));
|
|
}
|
|
item.sheet.render(true);
|
|
});
|
|
|
|
// Delete Inventory Item
|
|
html.find(".item-delete").on("click", (ev) => {
|
|
const li = $(ev.currentTarget).parents(".item");
|
|
this.actor.deleteEmbeddedDocuments("Item", [li.data("itemId")]);
|
|
li.slideUp(200, () => this.render(false));
|
|
});
|
|
|
|
html.find(".item-change").on("change", this.onItemChange.bind(this));
|
|
|
|
html.find(".rollable-item").on("click", this.onRollItem.bind(this));
|
|
|
|
html.find(".rollable-check").on("click", this.onRollCheck.bind(this));
|
|
}
|
|
|
|
/**
|
|
* Handle creating a new embedded Item for the actor using initial data defined in the HTML dataset
|
|
* @param event - The originating click event
|
|
*/
|
|
protected onItemCreate(event: JQuery.ClickEvent): void {
|
|
event.preventDefault();
|
|
const header = event.currentTarget;
|
|
|
|
const { type, ...data } = foundry.utils.deepClone(header.dataset);
|
|
|
|
const name = `New ${type.capitalize()}`;
|
|
|
|
const itemData = {
|
|
name: name,
|
|
type: type,
|
|
data: data,
|
|
};
|
|
|
|
DS4Item.create(itemData, { parent: this.actor });
|
|
}
|
|
|
|
/**
|
|
* Handle changes to properties of an Owned Item from within character sheet.
|
|
* Can currently properly bind: see getValue().
|
|
* Assumes the item property is given as the value of the HTML element property 'data-property'.
|
|
* @param ev - The originating change event
|
|
*/
|
|
protected onItemChange(ev: JQuery.ChangeEvent): void {
|
|
ev.preventDefault();
|
|
const el: HTMLFormElement = $(ev.currentTarget).get(0);
|
|
const id = $(ev.currentTarget).parents(".item").data("itemId");
|
|
const item = this.actor.items.get(id);
|
|
if (!item) {
|
|
throw new Error(getGame().i18n.format("DS4.ErrorActorDoesNotHaveItem", { id, actor: this.actor.name }));
|
|
}
|
|
const itemObject = item.toObject();
|
|
const property: string | undefined = $(ev.currentTarget).data("property");
|
|
|
|
// Early return:
|
|
// Disabled => do nothing
|
|
if (el.disabled || el.getAttribute("disabled")) return;
|
|
// name not given => raise
|
|
if (property === undefined) {
|
|
throw TypeError("HTML element does not provide 'data-property' attribute");
|
|
}
|
|
|
|
// Set new value
|
|
const newValue = this.getValue(el);
|
|
foundry.utils.setProperty(itemObject, property, newValue);
|
|
item.update(itemObject);
|
|
}
|
|
|
|
/**
|
|
* Collect the value of a form element depending on the element's type
|
|
* The value is parsed to:
|
|
* - Checkbox: boolean
|
|
* - Text input: string
|
|
* - Number: number
|
|
* @param el - The input element to collect the value of
|
|
*/
|
|
private getValue(el: HTMLFormElement): boolean | string | number {
|
|
// One needs to differentiate between e.g. checkboxes (value="on") and select boxes etc.
|
|
// Checkbox:
|
|
if (el.type === "checkbox") {
|
|
const value: boolean = el.checked;
|
|
return value;
|
|
}
|
|
|
|
// Text input:
|
|
else if (el.type === "text") {
|
|
const value: string = el.value;
|
|
return value;
|
|
}
|
|
|
|
// Numbers:
|
|
else if (el.type === "number") {
|
|
const value = Number(el.value.trim());
|
|
return value;
|
|
}
|
|
|
|
// // Ranges:
|
|
// else if (el.type === "range") {
|
|
// const value: string = el.value.trim();
|
|
// return value;
|
|
// }
|
|
|
|
// // Radio Checkboxes (untested, cf. FormDataExtended.process)
|
|
// else if (el.type === "radio") {
|
|
// const chosen: HTMLFormElement = el.find((r: HTMLFormElement) => r["checked"]);
|
|
// const value: string = chosen ? chosen.value : null;
|
|
// return value;
|
|
// }
|
|
|
|
// // Multi-Select (untested, cf. FormDataExtended.process)
|
|
// else if (el.type === "select-multiple") {
|
|
// const value: Array<string> = [];
|
|
// el.options.array.forEach((opt: HTMLOptionElement) => {
|
|
// if (opt.selected) value.push(opt.value);
|
|
// });
|
|
// return value;
|
|
|
|
// unsupported:
|
|
else {
|
|
throw new TypeError("Binding of item property to this type of HTML element not supported; given: " + el);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle clickable item rolls.
|
|
* @param event - The originating click event
|
|
*/
|
|
protected onRollItem(event: JQuery.ClickEvent): void {
|
|
event.preventDefault();
|
|
const id = $(event.currentTarget).parents(".item").data("itemId");
|
|
const item = this.actor.items.get(id);
|
|
if (!item) {
|
|
throw new Error(getGame().i18n.format("DS4.ErrorActorDoesNotHaveItem", { id, actor: this.actor.name }));
|
|
}
|
|
item.roll().catch((e) => notifications.error(e, { log: true }));
|
|
}
|
|
|
|
/**
|
|
* Handle clickable check rolls.
|
|
* @param event - The originating click event
|
|
*/
|
|
protected onRollCheck(event: JQuery.ClickEvent): void {
|
|
event.preventDefault();
|
|
const check = event.currentTarget.dataset["check"];
|
|
this.actor.rollCheck(check).catch((e) => notifications.error(e, { log: true }));
|
|
}
|
|
|
|
/** @override */
|
|
_onDragStart(event: DragEvent): void {
|
|
const target = event.currentTarget as HTMLElement;
|
|
if (!(target instanceof HTMLElement)) return super._onDragStart(event);
|
|
|
|
const check = target.dataset.check;
|
|
if (!check) return super._onDragStart(event);
|
|
|
|
if (!isCheck(check)) throw new Error(getGame().i18n.format("DS4.ErrorCannotDragMissingCheck", { check }));
|
|
|
|
const dragData = {
|
|
actorId: this.actor.id,
|
|
sceneId: this.actor.isToken ? getCanvas().scene?.id : null,
|
|
tokenId: this.actor.isToken ? this.actor.token?.id : null,
|
|
type: "Check",
|
|
data: check,
|
|
};
|
|
|
|
event.dataTransfer?.setData("text/plain", JSON.stringify(dragData));
|
|
}
|
|
|
|
/** @override */
|
|
protected async _onDropItem(event: DragEvent, data: ActorSheet.DropData.Item): Promise<unknown> {
|
|
const item = await DS4Item.fromDropData(data);
|
|
if (item && !this.actor.canOwnItemType(item.data.type)) {
|
|
notifications.warn(
|
|
getGame().i18n.format("DS4.WarningActorCannotOwnItem", {
|
|
actorName: this.actor.name,
|
|
actorType: this.actor.data.type,
|
|
itemName: item.name,
|
|
itemType: item.data.type,
|
|
}),
|
|
);
|
|
return false;
|
|
}
|
|
return super._onDropItem(event, data);
|
|
}
|
|
}
|
|
|
|
interface DS4ActorSheetData extends ActorSheet.Data<ActorSheet.Options> {
|
|
config: typeof DS4;
|
|
itemsByType: Record<string, foundry.data.ItemData[]>;
|
|
settings: DS4Settings;
|
|
}
|