FIx RE item data entries 2 (#651)

* Fix incorrect targeting data used for check outcome predicate
* Fix missing trait data on apply damage rule action
* Fix missing locality check for init. check trigger
* Update the volcano entry
* Fix up consume, crossfire and warning shot skill entries
* Fix brainwave clock not advancing on the new chat action
* Add the gadget infusion automation
* Implement an inline action command
* Add automation for painful lesson
* Update agony too

Author: Azurelol

lang/en.json

@@ -1625,6 +1625,7 @@
 		"RuleElement": "Rule Element",
 		"RuleElementOptions": "Rule Elements",
 		"RuleElementNew": "Add new rule element",
+		"RuleElementTriggered": "The triggering condition has been satisfied.",
 		"RuleActions": "Rule Actions",
 		"RuleActionMessage": "Message",
 		"RuleActionApplyDamage": "Apply Damage",

module/checks/check-configuration.mjs

@@ -309,7 +309,12 @@ class CheckConfigurer extends CheckInspector {
 		if (!this.check.additionalData[TRAITS]) {
 			this.check.additionalData[TRAITS] = [];
 		}
-		traits.forEach((t) => this.check.additionalData[TRAITS].push(t.toLowerCase()));
+
+		traits.flat().forEach((t) => {
+			if (t != null) {
+				this.check.additionalData[TRAITS].push(String(t).toLowerCase());
+			}
+		});
 		return this;
 	}
 

module/checks/common-sections.mjs

@@ -272,6 +272,7 @@ const actions = (sections, actor, item, targetData, flags, inspector = undefined
 		const isDamage = checkData && damageData;
 		const sourceInfo = InlineSourceInfo.fromInstance(actor, item);
 		const targets = Targeting.deserializeTargetData(targetData);
+		const traits = inspector.getTraits();
 
 		sections.push(async function () {
 			/** @type {ChatAction[]} **/
@@ -299,7 +300,7 @@ const actions = (sections, actor, item, targetData, flags, inspector = undefined
 
 			// Damage action
 			if (isDamage) {
-				actions.push(DamagePipeline.getTargetedAction(damageData, sourceInfo));
+				actions.push(DamagePipeline.getTargetedAction(damageData, sourceInfo, traits));
 
 				// TODO: Combine expenses among all actions?
 				for (const mod of damageData.modifiers) {

module/checks/damage-data.mjs

@@ -10,6 +10,7 @@
  * @property {Boolean} enabled
  * @property {number} amount
  * @property {DamageType[]} types
+ * @property {String[]} traits
  * @property {ResourceExpense} expense
  */
 
@@ -67,7 +68,9 @@ export class DamageData {
 	 * @remarks Returns only those modifiers that have been enabled.
 	 */
 	get modifiers() {
-		return this._modifiers.filter((m) => m.enabled && m.amount > 0);
+		return this._modifiers.filter((m) => {
+			return m.enabled && (m.amount > 0 || (m.traits && m.traits.length > 0));
+		});
 	}
 
 	/**

module/checks/default-section-order.mjs

@@ -8,6 +8,6 @@ export const CHECK_REROLL = -1100;
 
 export const CHECK_ROLL = -1000;
 
-export const CHECK_DAMAGE = -900;
+export const CHECK_ADDENDUM_ORDER = -900;
 
 export const CHECK_RESULT = 1000;

module/documents/actors/actor.mjs

@@ -539,8 +539,11 @@ export class FUActor extends Actor {
 			await progress.parent.parent.update({ [`system.${schemaName}.current`]: current });
 		}
 		// ActiveEffect
-		else if (progress.parent.parent instanceof FUActiveEffectModel) {
+		else if (progress.parent instanceof FUActiveEffectModel) {
 			await progress.parent.parent.update({ [`system.rules.progress.current`]: current });
+			// if (this.sheet.rendered) {
+			// 	this.sheet.render();
+			// }
 		}
 
 		// Update this instance for tracking, though it is not the same as the one that just got replaced in the model

module/documents/effects/actions/apply-damage-rule-action.mjs

@@ -4,12 +4,15 @@ import { ExpressionContext, Expressions } from '../../../expressions/expressions
 import { DamagePipeline, DamageRequest } from '../../../pipelines/damage-pipeline.mjs';
 import { RuleActionDataModel } from './rule-action-data-model.mjs';
 import { SETTINGS } from '../../../settings.js';
+import { TraitsDataModel } from '../../items/common/traits-data-model.mjs';
+import { DamageTraits, TraitUtils } from '../../../pipelines/traits.mjs';
 
 const fields = foundry.data.fields;
 
 /**
  * @property {String} amount
  * @property {FU.damageTypes} damageType
+ * @property {TraitsDataModel} traits
  */
 export class ApplyDamageRuleAction extends RuleActionDataModel {
 	static {
@@ -25,6 +28,9 @@ export class ApplyDamageRuleAction extends RuleActionDataModel {
 				blank: true,
 				nullable: false,
 			}),
+			traits: new fields.EmbeddedDataField(TraitsDataModel, {
+				options: TraitUtils.getOptions(DamageTraits),
+			}),
 		});
 	}
 
@@ -39,30 +45,36 @@ export class ApplyDamageRuleAction extends RuleActionDataModel {
 	async execute(context, selected) {
 		const targets = selected.map((t) => t.actor);
 		const expressionContext = ExpressionContext.fromSourceInfo(context.sourceInfo, targets).withCheck(context.check);
-		const amount = await Expressions.evaluateAsync(this.amount, expressionContext);
-		const request = new DamageRequest(context.sourceInfo, targets, {
-			type: this.damageType,
-			total: amount,
-		});
-		request.fromOrigin(context.origin);
-		if (game.settings.get(SYSTEM, SETTINGS.automationApplyDamage)) {
-			await DamagePipeline.process(request);
-		} else {
-			if (context.event.config) {
-				/** @type CheckConfigurer **/
-				const config = context.event.config;
-				if (context.check) {
-					switch (context.check.type) {
-						case 'display':
-							config.setDamage(this.damageType, amount);
-							break;
+		const evalAmount = await Expressions.evaluateAsync(this.amount, expressionContext);
+
+		if (context.config) {
+			if (context.check) {
+				const _traits = this.traits.values;
+				context.config.addTraits(_traits);
+
+				switch (context.check.type) {
+					case 'display':
+						context.config.setDamage(this.damageType, evalAmount);
+						break;
 
-						case 'accuracy':
-						case 'magic':
-							config.damage.addModifier(context.label, amount, [this.damageType]);
-							break;
-					}
+					case 'accuracy':
+					case 'magic':
+						context.config.damage.addModifier(context.label, evalAmount, [this.damageType]);
+						break;
 				}
+			}
+		} else {
+			const request = new DamageRequest(context.sourceInfo, targets, {
+				type: this.damageType,
+				total: evalAmount,
+			});
+			if (!this.traits.empty) {
+				request.addTraits(this.traits.values);
+			}
+			request.fromOrigin(context.origin);
+
+			if (game.settings.get(SYSTEM, SETTINGS.automationApplyDamage)) {
+				await DamagePipeline.process(request);
 			} else {
 				await DamagePipeline.promptApply(request);
 			}

module/documents/effects/actions/change-traits-rule-action.mjs

@@ -2,14 +2,13 @@ import { systemTemplatePath } from '../../../helpers/system-utils.mjs';
 import { RuleActionDataModel } from './rule-action-data-model.mjs';
 import { FUHooks } from '../../../hooks.mjs';
 import { FU } from '../../../helpers/config.mjs';
-import { Traits } from '../../../pipelines/traits.mjs';
-import FoundryUtils from '../../../helpers/foundry-utils.mjs';
+import { Traits, TraitUtils } from '../../../pipelines/traits.mjs';
 import { TraitsDataModel } from '../../items/common/traits-data-model.mjs';
 
 const fields = foundry.data.fields;
 
 /**
- * @property {Set<String>} traits
+ * @property {TraitsDataModel} traits
  * @property {FUChangeSetMode} mode
  */
 export class ChangeTraitsRuleAction extends RuleActionDataModel {
@@ -21,14 +20,14 @@ export class ChangeTraitsRuleAction extends RuleActionDataModel {
 	static get metadata() {
 		return {
 			...super.metadata,
-			eventTypes: [FUHooks.PERFORM_CHECK_EVENT],
+			eventTypes: [FUHooks.PERFORM_CHECK_EVENT, FUHooks.CALCULATE_DAMAGE_EVENT],
 		};
 	}
 
 	static defineSchema() {
 		return Object.assign(super.defineSchema(), {
 			traits: new fields.EmbeddedDataField(TraitsDataModel, {
-				options: FoundryUtils.getFormOptions(Traits, (k, v) => k),
+				options: TraitUtils.getOptions(Traits),
 			}),
 			mode: new fields.StringField({
 				initial: 'add',
@@ -47,16 +46,14 @@ export class ChangeTraitsRuleAction extends RuleActionDataModel {
 	}
 
 	async execute(context, selected) {
-		const values = this.traits.values();
-		if (context.eventType === FUHooks.CALCULATE_DAMAGE_EVENT) {
-			/** @type CalculateDamageEvent **/
-			const event = context.event;
+		const values = this.traits.values;
+		if (context.config) {
 			switch (this.mode) {
 				case 'add':
-					event.context.addTraits(values);
+					context.config.addTraits(values);
 					break;
 				case 'remove':
-					event.context.removeTraits(values);
+					//context.config.removeTraits(values);
 					break;
 			}
 		}

module/documents/effects/actions/message-rule-action.mjs

@@ -5,7 +5,8 @@ import { FUHooks } from '../../../hooks.mjs';
 import { CommonSections } from '../../../checks/common-sections.mjs';
 import { Flags } from '../../../helpers/flags.mjs';
 import { Pipeline } from '../../../pipelines/pipeline.mjs';
-import { CHECK_DETAILS } from '../../../checks/default-section-order.mjs';
+import { CHECK_ADDENDUM_ORDER } from '../../../checks/default-section-order.mjs';
+import { StringUtils } from '../../../helpers/string-utils.mjs';
 
 const { StringField } = foundry.data.fields;
 
@@ -45,20 +46,21 @@ export class MessageRuleAction extends RuleActionDataModel {
 	}
 
 	async execute(context, selected) {
-		let flags = Pipeline.initializedFlags(Flags.ChatMessage.Item, context.item);
+		let flags = Pipeline.initializedFlags(Flags.ChatMessage.Item, context.item.uuid);
+		let _message = this.message || StringUtils.localize('FU.RuleElementTriggered');
 		if (context.check) {
 			flags = Pipeline.setFlag(flags, Flags.ChatMessage.CheckV2, context.check);
 		}
 		if (context.eventType === FUHooks.RENDER_CHECK_EVENT) {
 			/** @type RenderCheckEvent **/
 			const rce = context.event;
 			const actor = rce.source.actor !== context.character.actor ? context.item.parent : null;
-			CommonSections.itemText(rce.renderData, this.message, actor, context.item, flags, CHECK_DETAILS);
+			CommonSections.itemText(rce.renderData, _message, actor, context.item, flags, CHECK_ADDENDUM_ORDER);
 		} else {
 			const actor = context.character.actor;
 			const content = await FoundryUtils.renderTemplate('chat/partials/chat-item-text', {
 				item: context.item,
-				text: this.message,
+				text: _message,
 			});
 			ChatMessage.create({
 				flags: flags,

module/documents/effects/actions/modify-damage-rule-action.mjs

@@ -5,13 +5,15 @@ import { ExpressionContext, Expressions } from '../../../expressions/expressions
 import { ActionCostDataModel } from '../../items/common/action-cost-data-model.mjs';
 import { FU } from '../../../helpers/config.mjs';
 import { SkillDataModel } from '../../items/skill/skill-data-model.mjs';
-import { SkillTraits } from '../../../pipelines/traits.mjs';
+import { DamageTraits, SkillTraits, TraitUtils } from '../../../pipelines/traits.mjs';
+import { TraitsDataModel } from '../../items/common/traits-data-model.mjs';
 
 const fields = foundry.data.fields;
 
 /**
  * @property {DamageType} damageType
  * @property {String} amount
+ * @property {TraitsDataModel} traits
  * @property {Set<DamageType>} damageTypes
  * @property {ActionCostDataModel} cost
  * @property {String} variant
@@ -32,6 +34,9 @@ export class ModifyDamageRuleAction extends RuleActionDataModel {
 		return Object.assign(super.defineSchema(), {
 			amount: new fields.StringField({ blank: true }),
 			damageTypes: new fields.SetField(new fields.StringField()),
+			traits: new fields.EmbeddedDataField(TraitsDataModel, {
+				options: TraitUtils.getOptions(DamageTraits),
+			}),
 			cost: new fields.EmbeddedDataField(ActionCostDataModel, {
 				resource: {
 					initial: '',
@@ -77,11 +82,12 @@ export class ModifyDamageRuleAction extends RuleActionDataModel {
 						return;
 					}
 					for (let sl = 1; sl <= skill.level.value; sl++) {
-						context.event.config.getDamage().addModifier(context.label, _amount * sl, types, {
+						context.config.getDamage().addModifier(context.label, _amount * sl, types, {
 							expense: {
 								amount: this.cost.amount * sl,
 								resource: this.cost.resource,
 							},
+							traits: this.traits.values,
 							enabled: false,
 						});
 					}
@@ -90,25 +96,29 @@ export class ModifyDamageRuleAction extends RuleActionDataModel {
 
 				case 'psychicGift': {
 					const brainwave = context.character.actor.resolveProgress('brainwave-clock');
-					context.event.config.getDamage().addModifier(context.label, _amount, types, {
+					context.config.getDamage().addModifier(context.label, _amount, types, {
 						expense: {
 							amount: Math.max(5, this.cost.amount * brainwave.current),
 							resource: this.cost.resource,
 							traits: [SkillTraits.Gift],
 						},
+						traits: this.traits.values,
 						enabled: false,
 					});
 					break;
 				}
 			}
 		} else {
-			if (this.damageTypes.size > 0 || this.cost.amount > 0) {
-				context.event.config.getDamage().addModifier(context.label, _amount, types, {
+			if (this.damageTypes.size > 0 || this.cost.amount > 0 || !this.traits.empty) {
+				context.config.getDamage().addModifier(context.label, _amount, types, {
 					expense: this.cost,
+					traits: this.traits.values,
 					enabled: this.cost.amount === 0,
 				});
 			} else {
-				context.event.config.addDamageBonus(context.label, _amount);
+				context.config.addDamageBonus(context.label, _amount);
+				// TODO: Verify...
+				context.config.addTraits(this.traits.values);
 			}
 		}
 	}