François-Xavier Guillois
249 lines
7.5 KiB
JavaScript
249 lines
7.5 KiB
JavaScript
import {onManageActiveEffect, prepareActiveEffectCategories} from "../system/effects.mjs";
|
||
import { VermineActorSheet } from "./actor-sheet.mjs";
|
||
import { getRollBox } from "../system/dialogs.mjs";
|
||
|
||
/**
|
||
* Extend the basic ActorSheet with some very simple modifications
|
||
* @extends {VermineActorSheet}
|
||
*/
|
||
export class VermineCharacterSheet extends VermineActorSheet {
|
||
|
||
/** @override */
|
||
static get defaultOptions() {
|
||
return mergeObject(super.defaultOptions, {
|
||
classes: ["vermine2047", "sheet", "actor"],
|
||
template: "systems/vermine2047/templates/actor/actor-sheet.html",
|
||
width: 600,
|
||
height: 600,
|
||
tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "features" }]
|
||
});
|
||
}
|
||
|
||
/** @override */
|
||
get template() {
|
||
return `systems/vermine2047/templates/actor/actor-character-sheet.html`;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
|
||
/** @override */
|
||
getData() {
|
||
// Retrieve the data structure from the base sheet. You can inspect or log
|
||
// the context variable to see the structure, but some key properties for
|
||
// sheets are the actor object, the data object, whether or not it's
|
||
// editable, the items array, and the effects array.
|
||
const context = super.getData();
|
||
|
||
// Use a safe clone of the actor data for further operations.
|
||
const actorData = this.actor.toObject(false);
|
||
|
||
// Add the actor's data to context.data for easier access, as well as flags.
|
||
context.system = actorData.system;
|
||
context.flags = actorData.flags;
|
||
context.config = CONFIG.VERMINE;
|
||
|
||
// Prepare character data and items.
|
||
if (actorData.type == 'character') {
|
||
this._prepareItems(context);
|
||
this._prepareCharacterData(context);
|
||
}
|
||
|
||
// Prepare NPC data and items.
|
||
if (actorData.type == 'npc') {
|
||
this._prepareItems(context);
|
||
}
|
||
|
||
// Add roll data for TinyMCE editors.
|
||
context.rollData = context.actor.getRollData();
|
||
|
||
// Prepare active effects
|
||
context.effects = prepareActiveEffectCategories(this.actor.effects);
|
||
|
||
return context;
|
||
}
|
||
|
||
/**
|
||
* Organize and classify Items for Character sheets.
|
||
*
|
||
* @param {Object} actorData The actor to prepare.
|
||
*
|
||
* @return {undefined}
|
||
*/
|
||
_prepareCharacterData(context) {
|
||
// Handle ability scores.
|
||
for (let [k, v] of Object.entries(context.system.abilities)) {
|
||
v.label = game.i18n.localize(context.system.abilities[k].label) ?? k;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Organize and classify Items for Character sheets.
|
||
*
|
||
* @param {Object} actorData The actor to prepare.
|
||
*
|
||
* @return {undefined}
|
||
*/
|
||
_prepareItems(context) {
|
||
// Initialize containers.
|
||
const gear = [];
|
||
const features = [];
|
||
const spells = {
|
||
0: [],
|
||
1: [],
|
||
2: [],
|
||
3: [],
|
||
4: [],
|
||
5: [],
|
||
6: [],
|
||
7: [],
|
||
8: [],
|
||
9: []
|
||
};
|
||
|
||
// Iterate through items, allocating to containers
|
||
for (let i of context.items) {
|
||
i.img = i.img || DEFAULT_TOKEN;
|
||
// Append to gear.
|
||
if (i.type === 'item') {
|
||
gear.push(i);
|
||
}
|
||
// Append to features.
|
||
else if (i.type === 'feature') {
|
||
features.push(i);
|
||
}
|
||
// Append to spells.
|
||
else if (i.type === 'spell') {
|
||
if (i.system.spellLevel != undefined) {
|
||
spells[i.system.spellLevel].push(i);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Assign and return
|
||
context.gear = gear;
|
||
context.features = features;
|
||
context.spells = spells;
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
|
||
/** @override */
|
||
activateListeners(html) {
|
||
super.activateListeners(html);
|
||
|
||
// Render the item sheet for viewing/editing prior to the editable check.
|
||
html.find('.item-edit').click(ev => {
|
||
const li = $(ev.currentTarget).parents(".item");
|
||
const item = this.actor.items.get(li.data("itemId"));
|
||
item.sheet.render(true);
|
||
});
|
||
|
||
// -------------------------------------------------------------
|
||
// Everything below here is only needed if the sheet is editable
|
||
if (!this.isEditable) return;
|
||
|
||
// Add Inventory Item
|
||
html.find('.item-create').click(this._onItemCreate.bind(this));
|
||
|
||
// Delete Inventory Item
|
||
html.find('.item-delete').click(ev => {
|
||
const li = $(ev.currentTarget).parents(".item");
|
||
const item = this.actor.items.get(li.data("itemId"));
|
||
item.delete();
|
||
li.slideUp(200, () => this.render(false));
|
||
});
|
||
|
||
// Active Effect management
|
||
html.find(".effect-control").click(ev => onManageActiveEffect(ev, this.actor));
|
||
|
||
// test print dice
|
||
// html.find(".skill").change(ev => this.printSkillLevels(ev, this.actor));
|
||
|
||
// Rollable abilities.
|
||
html.find('.rollable').click(this._onRoll.bind(this));
|
||
|
||
// Drag events for macros.
|
||
if (this.actor.isOwner) {
|
||
let handler = ev => this._onDragStart(ev);
|
||
html.find('li.item').each((i, li) => {
|
||
if (li.classList.contains("inventory-header")) return;
|
||
li.setAttribute("draggable", true);
|
||
li.addEventListener("dragstart", handler, false);
|
||
});
|
||
}
|
||
}
|
||
|
||
/*printSkillLevels(event){
|
||
const newLevel = event.target.value;
|
||
const levelData = CONFIG.VERMINE.SkillLevels[newLevel] || null;
|
||
if (levelData != null){
|
||
console.log(/*levelData.dicePool, levelData.reroll, game.i18n.localize(levelData.label), * /$(event.target).parent().find('.die.pool').get(0), $(event.target).parent().find('.die.reroll').get(0));
|
||
$(event.target).parent().find('.die.pool').text(levelData.dicePool);
|
||
$(event.target).parent().find('.die.reroll').text(levelData.reroll);
|
||
}
|
||
|
||
} */
|
||
|
||
/**
|
||
* Handle creating a new Owned Item for the actor using initial data defined in the HTML dataset
|
||
* @param {Event} event The originating click event
|
||
* @private
|
||
*/
|
||
async _onItemCreate(event) {
|
||
event.preventDefault();
|
||
const header = event.currentTarget;
|
||
// Get the type of item to create.
|
||
const type = header.dataset.type;
|
||
// Grab any data associated with this control.
|
||
const data = duplicate(header.dataset);
|
||
// Initialize a default name.
|
||
const name = `New ${type.capitalize()}`;
|
||
// Prepare the item object.
|
||
const itemData = {
|
||
name: name,
|
||
type: type,
|
||
system: data
|
||
};
|
||
// Remove the type from the dataset since it's in the itemData.type prop.
|
||
delete itemData.system["type"];
|
||
|
||
// Finally, create the item!
|
||
return await Item.create(itemData, {parent: this.actor});
|
||
}
|
||
|
||
/**
|
||
* Handle clickable rolls.
|
||
* @param {Event} event The originating click event
|
||
* @private
|
||
*/
|
||
_onRoll(event) {
|
||
event.preventDefault();
|
||
const element = event.currentTarget;
|
||
const dataset = element.dataset;
|
||
console.log("Ceci est un jet d'un personnage joueur");
|
||
// Handle item rolls.
|
||
if (dataset.rollType) {
|
||
if (dataset.rollType == 'item') {
|
||
const itemId = element.closest('.item').dataset.itemId;
|
||
const item = this.actor.items.get(itemId);
|
||
if (item) return item.roll();
|
||
}
|
||
}
|
||
|
||
// Handle rolls that supply the formula directly.
|
||
if (dataset.label) {
|
||
/*const label = game.i18n.localize(dataset.label) ? `[ability] ${game.i18n.localize(dataset.label)}` : '';
|
||
console.log($(element).attr('for'));
|
||
const NoD = this.actor.system.skills[$(element).attr('for').split('.')[2]]?.value || 0
|
||
return game.vermine2047.VermineRoll.roll(this.actor.id, label, NoD, 0, {});*/
|
||
let data = {
|
||
actorId: this.actor.id,
|
||
label: game.i18n.localize(dataset.label)
|
||
};
|
||
getRollBox(data);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
}
|