Actor sheet actions menu V2 (#972)

Author: Azurelol

lang/en.json

@@ -714,6 +714,7 @@
 		"DialogRemoveMessage": "Remove <strong>{label}</strong>?",
 		"DialogClearMessage": "Clear all elements?",
 		"DialogSelectionMissingError": "No items were selected!",
+		"DialogEntriesMissing": "No matching entries were found.",
 		"Success": "Success",
 		"Critical": "Critical",
 		"Failure": "Failure",
@@ -1954,6 +1955,8 @@
 			"Event": "Event",
 			"Lore": "Lore",
 			"Glossary": "Glossary"
-		}
+		},
+		"SwitchEquipment": "Switch Equipment",
+		"SwitchEquipmentChatMessage": "<strong>{actor}</strong> is now wearing the following equipment."
 	}
 }

module/documents/actors/actor.mjs

@@ -366,7 +366,7 @@ export class FUActor extends Actor {
 	 * Returns an array of items that match a given FUID and optionally an item type
 	 * @param {string} fuid - The FUID of the item(s) which you want to retrieve
 	 * @param {string} [type] - Optionally, a type name to restrict the search
-	 * @returns {Array} - An array containing the found items
+	 * @returns {FUItem[]} - An array containing the found items
 	 */
 	getItemsByFuid(fuid, type) {
 		const fuidFilter = (i) => i.system.fuid === fuid;

module/documents/actors/common/equip-data-model.mjs

@@ -1,3 +1,13 @@
+/**
+ * @typedef CharacterEquipment
+ * @property mainHand
+ * @property offHand
+ * @property armor
+ * @property accessory
+ */
+
+import { FU } from '../../../helpers/config.mjs';
+
 /**
  * @property {string} armor
  * @property {string} mainHand
@@ -47,6 +57,22 @@ export class EquipDataModel extends foundry.abstract.DataModel {
 		return equipment;
 	}
 
+	/**
+	 * @param {FUActor} actor
+	 * @param {'mainHand', 'offHand', 'phantom', 'armor'} slot
+	 * @return {FUItem|null}
+	 */
+	static getEquipment(actor, slot) {
+		return (
+			[actor.system.equipped[slot]]
+				.filter((value) => value)
+				.map((value) => actor.items.get(value))
+				.filter((value) => value)
+				.filter((value) => value.type in FU.weaponItemTypes)
+				.at(0) ?? null
+		);
+	}
+
 	/**
 	 * @param {FUItem} item
 	 * @return {null,"mainHand","offHand","phantom","armor","accessory","arcanum"}

module/documents/effects/active-effect-behaviour-mixin.mjs

@@ -316,6 +316,18 @@ export function ActiveEffectBehaviourMixin(BaseDocument) {
 			}
 		}
 
+		/**
+		 * @param {function(RuleElementDataModel): boolean} predicate
+		 */
+		findRuleElement(predicate) {
+			for (const rule of this.system.rules.elements) {
+				if (predicate(rule)) {
+					return rule;
+				}
+			}
+			return undefined;
+		}
+
 		/**
 		 * @description Emits a chat message with this effect
 		 * @returns {Promise<void>}

module/documents/effects/predicates/weapon-rule-predicate.mjs

@@ -91,8 +91,8 @@ export class WeaponRulePredicate extends RulePredicateDataModel {
 		// If not using the event attack item...
 		if (!attackItem) {
 			if (character.actor.type === 'character') {
-				const mainHand = WeaponResolver.getWeapon(context.character.actor, 'mainHand');
-				const offHand = WeaponResolver.getWeapon(context.character.actor, 'offHand');
+				const mainHand = WeaponResolver.getEquipment(context.character.actor, 'mainHand');
+				const offHand = WeaponResolver.getEquipment(context.character.actor, 'offHand');
 				attackItem = mainHand ?? offHand;
 			} else if (character.actor.type === 'npc') {
 				/** @type {BasicItemDataModel[]} **/

module/documents/items/skill/base-skill-data-model.mjs

@@ -110,6 +110,7 @@ Hooks.on(CheckHooks.renderCheck, onRenderDisplay);
  * @property {ActionCostDataModel} cost
  * @property {TargetingDataModel} targeting
  * @property {Set<String>} traits
+ * @property {Boolean} hasRoll.value
  */
 export class BaseSkillDataModel extends FUStandardItemDataModel {
 	static defineSchema() {
@@ -157,6 +158,25 @@ export class BaseSkillDataModel extends FUStandardItemDataModel {
 		return [];
 	}
 
+	/**
+	 * @returns {boolean} Whether this is a passive skill.
+	 * @remarks This is used to determine whether to show this skill in some UIs.
+	 */
+	get passive() {
+		let active = this.hasRoll.value || this.useWeapon.accuracy || this.damage.hasDamage || this.effects.entries.size > 0;
+		/** @type {FUItem} **/
+		const item = this.parent;
+		for (const effect of item.effects) {
+			const rollRule = effect.findRuleElement((rule) => {
+				return rule.trigger.type === 'itemRollRuleTrigger';
+			});
+			if (rollRule !== undefined) {
+				active = true;
+			}
+		}
+		return !active;
+	}
+
 	/**
 	 * @param {KeyboardModifiers} modifiers
 	 * @return {Promise<void>}

module/documents/items/skill/weapon-resolver.mjs

@@ -14,7 +14,7 @@ import FoundryUtils from '../../../helpers/foundry-utils.mjs';
  * @param {'mainHand', 'offHand', 'phantom', 'armor'} slot
  * @return {FUItem|null}
  */
-function getWeapon(actor, slot) {
+function getEquipment(actor, slot) {
 	return (
 		[actor.system.equipped[slot]]
 			.filter((value) => value)
@@ -34,24 +34,24 @@ function getEquippedWeapons(actor, includeWeaponModules) {
 	let equippedWeapons = [];
 
 	if (actor.system instanceof CharacterDataModel) {
-		const phantomHand = getWeapon(actor, 'phantom');
+		const phantomHand = getEquipment(actor, 'phantom');
 		if (includeWeaponModules && actor.system.vehicle.embarked && actor.system.vehicle.weapons.length > 0) {
 			let modules = actor.system.vehicle.weapons;
 			modules = modules.filter((w) => w.system.data.type !== 'shield' || w === phantomHand);
 			equippedWeapons.push(...modules, phantomHand);
 		} else {
-			const mainHand = getWeapon(actor, 'mainHand');
-			const offHand = getWeapon(actor, 'offHand');
-			const armor = getWeapon(actor, 'armor');
+			const mainHand = getEquipment(actor, 'mainHand');
+			const offHand = getEquipment(actor, 'offHand');
+			const armor = getEquipment(actor, 'armor');
 
 			equippedWeapons.push(...new Set([mainHand, offHand, phantomHand, armor]));
 		}
 	}
 	if (actor.system instanceof NpcDataModel) {
 		if (actor.system.useEquipment.value) {
-			const mainHand = getWeapon(actor, 'mainHand');
-			const offHand = getWeapon(actor, 'offHand');
-			const armor = getWeapon(actor, 'armor');
+			const mainHand = getEquipment(actor, 'mainHand');
+			const offHand = getEquipment(actor, 'offHand');
+			const armor = getEquipment(actor, 'armor');
 
 			equippedWeapons.push(...new Set([mainHand, offHand, armor]));
 		} else {
@@ -221,7 +221,7 @@ function getAccuracy(weapon) {
 
 export const WeaponResolver = Object.freeze({
 	prompt,
-	getWeapon,
+	getEquipment,
 	getEquippedWeapons,
 	getAccuracy,
 });

module/helpers/action-handler.mjs

@@ -9,6 +9,9 @@ import { CheckHooks } from '../checks/check-hooks.mjs';
 import { CHECK_FLAVOR } from '../checks/default-section-order.mjs';
 import { CheckConfiguration } from '../checks/check-configuration.mjs';
 import { StringUtils } from './string-utils.mjs';
+import { WeaponResolver } from '../documents/items/skill/weapon-resolver.mjs';
+import FoundryUtils from './foundry-utils.mjs';
+import { EquipmentHandlerDialog } from './equipment-handler.mjs';
 
 const actionKey = 'ruleDefinedAction';
 
@@ -48,7 +51,8 @@ const onRenderCheck = (data, check, actor) => {
 Hooks.on(CheckHooks.renderCheck, onRenderCheck);
 
 /**
- * @desc Encapsulates basic character actions.\
+ * @desc Encapsulates basic character actions.
+ * @property {FUActor} actor
  * @property {Number} bonus
  */
 export class ActionHandler {
@@ -65,19 +69,27 @@ export class ActionHandler {
 		return this;
 	}
 
+	/**
+	 *
+	 * @param {FUActionType} actionType
+	 * @param isShift
+	 * @returns {Promise<void>}
+	 */
 	async handleAction(actionType, isShift = false) {
 		if (!isShift) {
 			switch (actionType) {
+				case 'attack':
+					return this.attack();
 				case 'equipment':
-					return this.createActionMessage(actionType);
+					return this.equipment();
 				case 'guard':
 					return this.toggleGuardEffect(this.actor);
 				case 'hinder':
 					return this.promptHinderCheck();
 				case 'inventory':
 					return this.createActionMessage(actionType);
 				case 'objective':
-					return this.createActionMessage(actionType);
+					return this.objective();
 				case 'spell':
 					return this.createActionMessage(actionType);
 				case 'study':
@@ -123,6 +135,35 @@ export class ActionHandler {
 		});
 	}
 
+	/**
+	 * @desc Performs an attack with one of the equipped weapons or attacks.
+	 * @returns {Promise<void>}
+	 */
+	async attack() {
+		const resolution = await WeaponResolver.prompt(this.actor, true);
+		if (resolution?.item) {
+			resolution.item.roll();
+		}
+	}
+
+	/**
+	 * @desc Attempts to roll a check for one of the existing clocks.
+	 * @returns {Promise<void>}
+	 */
+	async objective() {
+		// TODO: Look at active clocks in party/scene and roll a check to advance them
+		return CheckPrompt.attributeCheck(this.actor);
+	}
+
+	/**
+	 * @desc Opens a dialog to swap the current equipment.
+	 * @returns {Promise<void>}
+	 */
+	async equipment() {
+		const dialog = new EquipmentHandlerDialog(this.actor);
+		dialog.render(true);
+	}
+
 	/**
 	 * Create a chat message for a given action.
 	 * @param {string} action - The type of action to create a message for.
@@ -155,4 +196,37 @@ export class ActionHandler {
 			await this.createActionMessage('guard');
 		}
 	}
+
+	static skillsWithApps = ['invocations', 'verse'];
+
+	/**
+	 * @param {FUActor} actor
+	 * @param element
+	 */
+	static setupMenu(actor, element) {
+		// ATTACKS
+		const attacks = WeaponResolver.getEquippedWeapons(actor, true);
+		FoundryUtils.itemContextMenu(element, '[data-context-menu="attack"]', attacks);
+		// SPELLS
+		const spells = ['spell'].map((t) => actor.getItemsByType(t)).flat();
+		FoundryUtils.itemContextMenu(element, '[data-context-menu="spell"]', spells);
+		// INVENTORY
+		const consumables = ['consumable'].map((t) => actor.getItemsByType(t)).flat();
+		FoundryUtils.itemContextMenu(element, '[data-context-menu="inventory"]', consumables);
+		// SKILLS
+		/** @type {FUItem[]} **/
+		let skills = ['skill', 'miscAbility']
+			.map((t) => actor.getItemsByType(t))
+			.flat()
+			.filter((s) => {
+				return !s.system.passive;
+			});
+		for (const fuid of ActionHandler.skillsWithApps) {
+			const skill = actor.getItemsByFuid(fuid);
+			if (skill) {
+				skills.push(...skill);
+			}
+		}
+		FoundryUtils.itemContextMenu(element, '[data-context-menu="skill"]', skills);
+	}
 }

module/helpers/config.mjs

@@ -291,15 +291,15 @@ FU.actionTypes = {
 };
 
 FU.actionIcons = {
-	attack: 'ra ra-crossed-swords', // attack / melee
-	equipment: 'ra ra-armor', // equipment / gear
-	guard: 'ra ra-shield', // guard / defense
-	hinder: 'ra ra-interdiction', // hinder / block
-	inventory: 'ra ra-ammo-bag', // inventory / bag
-	objective: 'ra ra-targeted', // objective / goal
-	spell: 'ra ra-crystal-wand', // spell / magic
-	study: 'ra ra-book', // study / learn
-	skill: 'ra ra-muscle-up', // skill / ability improvement
+	attack: 'ra ra-crossed-swords',
+	equipment: 'ra ra-vest',
+	guard: 'ra ra-shield',
+	hinder: 'ra ra-interdiction',
+	inventory: 'ra ra-ammo-bag',
+	objective: 'ra ra-targeted',
+	spell: 'ra ra-crystal-wand',
+	study: 'ra ra-book',
+	skill: 'ra ra-muscle-up',
 };
 
 FU.actionRule = {
@@ -1141,6 +1141,7 @@ FU.allIcon = {
 
 	...FU.bondIcons,
 
+	...FU.actionIcons,
 	roll: FU.checkIcons.open,
 	...FU.checkIcons,
 	...FU.affinityIcons,
@@ -1178,3 +1179,13 @@ FU.codexTags = Object.freeze({
 	lore: 'FU.CODEX.Lore',
 	glossary: 'FU.CODEX.Glossary',
 });
+
+/**
+ * @typedef {'mainHand', 'offHand', 'armor', 'accessory', 'phantom', 'arcanum'} FUEquipmentSlot
+ */
+
+FU.equipmentSlots = {
+	mainHand: 'FU.MainHand',
+	offHand: 'FU.OffHand',
+	phantom: 'FU.PhantomHand',
+};