140 lines
4.7 KiB
JavaScript
140 lines
4.7 KiB
JavaScript
import { RdDItemArme } from "./item-arme.js";
|
|
import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
|
|
import { ITEM_TYPES } from "./item.js";
|
|
|
|
export class RdDHotbar {
|
|
|
|
static async createItemMacro(item, slot, armeCompetence = undefined) {
|
|
const itemName = item.name;
|
|
let macroName = itemName + RdDHotbar.$macroNameSuffix(armeCompetence);
|
|
let command = `game.system.rdd.RdDHotbar.rollMacro("${itemName}", "${item.type}", "${armeCompetence}");`
|
|
let macro = game.macros.contents.find(m => (m.name === itemName) && (m.command === command));
|
|
if (!macro) {
|
|
macro = await Macro.create({
|
|
name: macroName,
|
|
type: "script",
|
|
img: item.img,
|
|
command: command
|
|
}, { displaySheet: false })
|
|
}
|
|
await game.user.assignHotbarMacro(macro, slot);
|
|
}
|
|
|
|
static $macroNameSuffix(armeCompetence) {
|
|
switch (armeCompetence) {
|
|
case 'unemain': return ' (1 main)';
|
|
case 'deuxmains': return ' (2 main)';
|
|
case 'tir': return ' (tir)';
|
|
case 'lancer': return ' (lancer)';
|
|
case 'pugilat': return ' (pugilat)';
|
|
case 'empoignade': return ' (empoignade)';
|
|
|
|
}
|
|
return ''
|
|
}
|
|
|
|
static async addToHotbar(item, slot) {
|
|
switch (item?.type ?? '') {
|
|
case ITEM_TYPES.arme:
|
|
{
|
|
// Les armes peuvent avoir plusieurs usages
|
|
if (item.system.competence != '') {
|
|
if (item.system.unemain) {
|
|
await this.createItemMacro(item, slot++, 'unemain')
|
|
}
|
|
if (item.system.deuxmains) {
|
|
await this.createItemMacro(item, slot++, 'deuxmains')
|
|
}
|
|
}
|
|
if (item.system.lancer != '') {
|
|
await this.createItemMacro(item, slot++, 'lancer')
|
|
}
|
|
if (item.system.tir != '') {
|
|
await this.createItemMacro(item, slot++, 'lancer')
|
|
}
|
|
}
|
|
return
|
|
case ITEM_TYPES.competencecreature:
|
|
const categorie = RdDItemCompetenceCreature.getCategorieAttaque(item) ?? 'competence';
|
|
await this.createItemMacro(item, slot, categorie)
|
|
return
|
|
default:
|
|
case ITEM_TYPES.competence:
|
|
await this.createItemMacro(item, slot++, 'competence')
|
|
if (item.isCorpsACorps()) {
|
|
await this.createItemMacro(item, slot++, 'pugilat')
|
|
await this.createItemMacro(item, slot++, 'empoignade')
|
|
}
|
|
else if (item.isCompetenceArme()) {
|
|
ui.notifications.info(`${item.name} est une compétence d'arme, la macro n'est pas liée à un arme.<br>
|
|
Créez la macro depuis l'arme ou l'onglet combat pour garder les automatisations de combat.`);
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a macro when dropping an entity on the hotbar
|
|
* Item - open roll dialog for item
|
|
* Actor - open actor sheet
|
|
* Journal - open journal sheet
|
|
*/
|
|
static init() {
|
|
|
|
Hooks.on('hotbarDrop', (bar, documentData, slot) => {
|
|
|
|
// Create item macro if rollable item - weapon, spell, prayer, trait, or skill
|
|
if (documentData.type == 'Item') {
|
|
const item = fromUuidSync(documentData.uuid) ?? this.actor.items.get(documentData.uuid)
|
|
console.log('DROP', documentData, item)
|
|
switch (item?.type) {
|
|
case ITEM_TYPES.arme:
|
|
case ITEM_TYPES.competence:
|
|
case ITEM_TYPES.competencecreature:
|
|
this.addToHotbar(item, slot)
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
})
|
|
}
|
|
|
|
/** Roll macro */
|
|
static rollMacro(itemName, itemType, categorieArme = 'competence') {
|
|
const speaker = ChatMessage.getSpeaker();
|
|
let actor;
|
|
if (speaker.token) actor = game.actors.tokens[speaker.token];
|
|
if (!actor) actor = game.actors.get(speaker.actor);
|
|
if (!actor) {
|
|
return ui.notifications.warn(`Impossible de trouver le personnage concerné`);
|
|
}
|
|
let item = actor?.items.find(it => it.name === itemName && it.type == itemType) ?? undefined;
|
|
if (!item) {
|
|
return ui.notifications.warn(`Impossible de trouver l'objet de cette macro`);
|
|
}
|
|
|
|
// Trigger the item roll
|
|
switch (item.type) {
|
|
case ITEM_TYPES.arme:
|
|
return actor.rollArme(item, categorieArme);
|
|
case ITEM_TYPES.competence:
|
|
if (item.isCorpsACorps()) {
|
|
switch (categorieArme) {
|
|
case 'pugilat':
|
|
return actor.rollArme(RdDItemArme.mainsNues(actor), 'competence');
|
|
case 'empoignade':
|
|
return actor.rollArme(RdDItemArme.empoignade(actor), 'competence');
|
|
}
|
|
}
|
|
return actor.rollCompetence(item);
|
|
case ITEM_TYPES.competencecreature:
|
|
return item.system.iscombat && !item.system.isparade
|
|
? actor.rollArme(item, categorieArme)
|
|
: actor.rollCompetence(item);
|
|
|
|
}
|
|
}
|
|
|
|
}
|