player-03 · June 24, 2024 23:00
diff --git a/Improvised weapon macro.js b/Improvised weapon macro.js
 //A macro for PF2e in FoundryVTT that helps you create improvised weapons
 //on the fly. It provides a menu of traits and damage types to pick from,
 //and will create and equip the item once you're done.

 //As usual, remember that your GM has final say on what an improvised
 //weapon does. Work with them to figure out what statistics make sense.
 //In particular, it won't always make sense to increase the weapon's
 //damage die, even though the macro allows it.

 //Options
 //=======

 //What do you want to call your weapons by default?
 const DEFAULT_WEAPON_NAME = "Improvised Weapon";

 //How large of an item does your character usually wield? Enter "med" for
 //medium or "lg" if you are a giant instinct barbarian.
 const DEFAULT_WEAPON_SIZE = "med";

 //What damage type should be selected by default? Must be "bludgeoning",
 //"piercing", or "slashing".
 const DEFAULT_DAMAGE_TYPE = "bludgeoning";

 //An approximate measure of how strong your improvised weapons are. 2 means
 //they'll be about as strong as a simple weapon. 3 would put them between
 //simple and martial weapons, and 4 would put them on par with many martial
 //weapons. Get your GM's permission before changing this!
 const IMPROVEMENTS = 2;

 //Preparation
 //===========

 //Don't touch anything from here on, unless you know what you're doing.

 const WINDOW_TITLE = "Improvise a Weapon";
 for(const existingDialog of document.getElementsByClassName("dialog")) {
 	if(existingDialog.getElementsByClassName("window-title")[0].textContent === WINDOW_TITLE) {
 		return;
 	}
 }

 let defaultWeaponName = DEFAULT_WEAPON_NAME;
 const existingWeaponIDs = [];
 for(let item of actor.inventory) {
 	if(item.system.traits.otherTags.includes("improvised") && item.system.quantity > 0
 		&& item.system.equipped.carryType === "held") {
 		existingWeaponIDs.push(item.id);
 	}
 }

 //Set up the base weapon. This will be filled out later, in `collectResults()`.
 let weapon = {
 	flags: {
 		core: { },
 		pf2e: { }
 	},
 	img: "systems/pf2e/icons/unidentified_item_icons/adventuring_gear.webp",
 	name: DEFAULT_WEAPON_NAME,
 	ownership: { default: 0 },
 	parent: actor,
 	permission: { default: 0 },
 	sort: 0,
 	system: {
 		bonus: { value: 0 },
 		bonusDamage: { value: 0 },
 		bulk: {
 			per: 1,
 			value: 0.1
 		},
 		category: "simple",
 		damage: {
 			damageType: DEFAULT_DAMAGE_TYPE,
 			dice: 1,
 			die: "d4",
 			modifier: 0,
 			persistent: null
 		},
 		description: {
 			gm: "",
 			value: ""
 		},
 		hardness: 5,
 		hp: { value: 20, max: 20, brokenThreshold: 10 },
 		identification: { status: "identified" },
 		level: { value: 0 },
 		publication: { title: "Pathfinder Player Core", license: "ORC", remaster: true, authors: "" },
 		quantity: 1,
 		rules: [],
 		runes: { potency: 0, striking: 0, property: [] },
 		size: DEFAULT_WEAPON_SIZE,
 		slug: null,
 		splashDamage: { value: 0 },
 		traits: {
 			value: [],
 			otherTags: ["improvised"],
 			rarity: "common"
 		},
 		usage: {
 			hands: 1,
 			type: "held",
 			value: "held-in-one-hand"
 		}
 	},
 	type: "weapon"
 };

 //Dialog window
 //=============

 let [ableToContinue, existingWeapon, handsHeld, damageDie] = await new Promise((resolve) => {
 	//CSS
 	//===
 	
 	const VALUE_NEW_WEAPON = "new-weapon";
 	
 	let content = "<style>\n"
 			//Checkboxes are too large by default, for how many we use.
 			+ "input[type=checkbox] { width: unset; height: unset; }\n"
 			//Text boxes are too long by default.
 			+ "input[type=text] { width: unset; }\n"
 			//Try to prevent line breaks right after a checkbox.
 			+ ".nowrap { white-space: nowrap; }\n"
 			//Some options depend on others, and should only show up once the
 			//dependency is chosen.
 			+ "input:not(:checked) ~ .requiresCheck { display: none; }\n"
 			+ "input:checked ~ .requiresNoCheck { display: none; }\n"
 		+ "</style>\n";
 	
 	//Weapon fundamentals
 	//===================
 	
 	//Existing weapon selection
 	//-------------------------
 	
 	const CLASS_WEAPON_SELECTION = "improvised-weapon-selection";
 	const CLASS_WEAPON_NAME = "improvised-weapon-name";
 	const CLASS_WEAPON_IMAGE = "improvised-weapon-image";
 	
 	const WEAPON_NAME_INPUT = `<image class="${ CLASS_WEAPON_IMAGE }" style="max-height: 2em; vertical-align: middle;" src="${ weapon.img }"> <input type="text" class="${ CLASS_WEAPON_NAME }" placeholder="${ DEFAULT_WEAPON_NAME }" value="${ DEFAULT_WEAPON_NAME }">`;
 	
 	content += '<div style="max-height: 200px; overflow: scroll;">';
 	
 	if(existingWeaponIDs.length > 0) {
 		content += `Interacting to:<br>`;
 		
 		for(const weaponID of existingWeaponIDs) {
 			const weapon = actor.inventory.get(weaponID);
 			content += `<label><input type="radio" class="${ CLASS_WEAPON_SELECTION }" name="${ CLASS_WEAPON_SELECTION }" value="${ weaponID }"${ weaponID === existingWeaponIDs[0] ? 'checked="true"' : "" }> `
 				+ `change grip on <image style="max-height: 1.5em; vertical-align: middle;" src="${ weapon.img }"> <strong>${ weapon.name }</strong></label><br>`;
 		}
 		
 		content += `<input type="radio" id="pick-up-new-weapon" class="${ CLASS_WEAPON_SELECTION }" name="${ CLASS_WEAPON_SELECTION }" value="${ VALUE_NEW_WEAPON }">`
 			+ '<label for="pick-up-new-weapon"> pick up a new '
 			+ WEAPON_NAME_INPUT
 			+ "</label>\n";
 		
 		content += '<div class="requiresCheck">';
 	} else {
 		content += "Picking up a(n) " + WEAPON_NAME_INPUT;
 	}
 	
 	//Size selection
 	//--------------
 	
 	const CLASS_SIZE = "weapon-size";
 	const VALUE_LARGE = "large";
 	content += `<p><label>Oversize weapon? <input type="checkbox"${ DEFAULT_WEAPON_SIZE === "lg" ? ' checked="true"' : "" } class="${ CLASS_SIZE }" value="${ VALUE_LARGE }"></label></p>\n`;
 	
 	//Damage type selection
 	//---------------------
 	
 	const CLASS_DAMAGE_TYPE = "damage-type";
 	content += "<p>Base damage: "
 	for(const type of ["bludgeoning", "piercing", "slashing"]) {
 		content += `<label><input type="radio" class="${ CLASS_DAMAGE_TYPE }" name="${ CLASS_DAMAGE_TYPE }" value="${ type }"${ type === DEFAULT_DAMAGE_TYPE ? ' checked="true"' : "" }> ${ type.charAt(0).toUpperCase() + type.substring(1) }</label>`;
 	}
 	content += "</p></div>\n"
 	
 	//Clean up after `<div class="requiresChecked">`.
 	if(existingWeaponIDs.length > 0) {
 		content += "</div>\n";
 	}
 	
 	//Improvement selection
 	//=====================
 	
 	const CLASS_IMPROVEMENTS_HEADER = "dialog-select-improvements-header";
 	
 	content += `<div><h2 class="${ CLASS_IMPROVEMENTS_HEADER }">Improvements</h2>\n`;
 	
 	const CLASS_IMPROVEMENT = "improvement";
 	
 	function improvementCheckbox(value, label, childNode) {
 		return '<label class="nowrap">'
 			+ `<input type="checkbox" class="${ CLASS_IMPROVEMENT }" value="${ value }">`
 			+ `<span class="tag">${ label }</span>${ childNode ?? "" }</label>`;
 	}
 	
 	//Option 1
 	//--------
 	
 	content += "<p><strong>Increase base damage:</strong> "
 		+ improvementCheckbox("d6", "d6 (2-hand d8)",
 			improvementCheckbox("d8", "d8 (2-hand d10)").replace('class="', 'class="requiresCheck '))
 		+ "</p><hr>\n";
 	
 	//Option 2
 	//--------
 	
 	content += '<div style="max-height: 40px; overflow: scroll;">\n<strong>Add bonus damage:</strong> '
 	
 	const damageTypeOptions = ["acid", "cold", "electricity", "fire", "mental", "poison", "sonic", "spirit", "vitality", "void"];
 	for(const damageType of damageTypeOptions) {
 		const damageTypeCapitalized = damageType.charAt(0).toUpperCase() + damageType.substring(1);
 		content += improvementCheckbox(damageType, damageTypeCapitalized)
 			+ "\n";
 	}
 	
 	content += "</div><hr>\n";
 	
 	//Option 3
 	//--------
 	
 	const availableTraits = [
 		"Agile",
 		"Backstabber",
 		"Backswing",
 		"Brace",
 		"Deadly",
 		"Disarm",
 		"Finesse",
 		"Forceful",
 		"Grapple",
 		"Nonlethal",
 		"Parry",
 		"Razing",
 		"Reach",
 		"Shove",
 		"Sweep",
 		"Trip",
 		"Versatile B",
 		"Versatile P",
 		"Versatile S",
 		
 		//Thrown gets special treatment due to how many traits depend on it.
 		//This also makes it a good choice to use as a divider.
 		"Thrown 10",
 		
 		//Less-useful traits go at the end, after the divider.
 		"Climbing",
 		"Concealable",
 		"Free-Hand",
 		"Hampering"
 	];
 	const thrownTraits = [
 		"Ranged Trip",
 		"Recovery",
 		"Tethered"
 	];
 	
 	content += '<div class="tags" data-tooltip-class="pf2e" style="max-height: 100px; overflow: scroll;">\n<p><strong>Add traits:</strong>'
 	
 	for(const trait of availableTraits) {
 		const slug = trait.toLowerCase().replace(/ /g, "-");
 		
 		function tagCheckbox(slug, trait) {
 			const traitTooltip = "PF2E.TraitDescription" + trait.replace(/[ \-]/g, "")
 				.replace(/Versatile[A-Z]/, "Versatile").replace(/Thrown\d+/, "Thrown");
 			
 			return improvementCheckbox(slug, trait)
 				.replace('class="nowrap"', `class="nowrap" data-trait="${ slug }" data-tooltip="${ traitTooltip }"`);
 		}
 		
 		if(slug.startsWith("thrown")) {
 			content += '</p><p>\n';
 			
 			content += `<input type="checkbox" class="improvement" id="improvement-${ slug }" value="${ slug }">`;
 			content += `<label class="tag" data-trait="thrown-10" data-tooltip="PF2E.TraitDescriptionThrown" for="improvement-${ slug }">Thrown</label><label for="improvement-${ slug }" class="requiresNoCheck"> …</label> `;
 			
 			content += '<span class="requiresCheck">'
 			for(let trait2 of thrownTraits) {
 				const slug2 = trait2.toLowerCase().replace(" ", "-");
 				content += tagCheckbox(slug2, trait2) + " ";
 			}
 			content += "</span></p><p>\n";
 			
 			continue;
 		}
 		
 		content += tagCheckbox(slug, trait) + "\n";
 	}
 	
 	content += "</p></div>\n"; //TODO: add <hr> if there's a fourth section.
 	
 	content += "</div>";
 	
 	//Additional scripts
 	//==================
 	
 	//A script to insert into the dialog window as a `<script>` tag. The whole
 	//function will be converted to a string. It could be written as a string in
 	//the first place, but that would make it harder to read.
 	function scriptFunction() {
 		const dialog = Array.from(document.getElementsByClassName("dialog")).find(
 			(d) => d.getElementsByClassName("window-title")[0]?.textContent === WINDOW_TITLE);
 		if(!dialog) {
 			return;
 		}
 		
 		const weaponImage = dialog.getElementsByClassName(CLASS_WEAPON_IMAGE)[0];
 		const weaponSize = dialog.getElementsByClassName(CLASS_SIZE)[0];
 		const damageTypes = Array.from(dialog.getElementsByClassName(CLASS_DAMAGE_TYPE));
 		const weaponSelection = dialog.getElementsByClassName(CLASS_WEAPON_SELECTION);
 		const improvements = dialog.getElementsByClassName(CLASS_IMPROVEMENT);
 		const improvementHeader = dialog.getElementsByClassName(CLASS_IMPROVEMENTS_HEADER)[0];
 		const confirmButtons = dialog.getElementsByClassName("dialog-button");
 		
 		let existingWeaponSelected = false;
 		
 		//We'll need to look up checkboxes by value pretty often.
 		const improvementMap = { };
 		for(const improvement of improvements) {
 			improvementMap[improvement.value] = improvement;
 		}
 		
 		//Weapon selection
 		//================
 		
 		if(weaponSelection.length > 0) {
 			const inventory = game.actors.get(ACTOR_ID).inventory;
 			
 			function onWeaponSelectionChange(changedButton) {
 				//This function is called twice per click, since two buttons
 				//change at once. We only care about the newly-checked button.
 				if(!changedButton.checked) {
 					return;
 				}
 				
 				//Reset all checkboxes.
 				weaponSize.checked = DEFAULT_WEAPON_SIZE === "lg";
 				for(const damageType of damageTypes) {
 					damageType.checked = damageType.value === DEFAULT_DAMAGE_TYPE;
 				}
 				for(const improvementCheckbox of improvements) {
 					improvementCheckbox.checked = false;
 				}
 				
 				//Fill in checkboxes to match the selected weapon, if any.
 				const existingWeapon = inventory.get(changedButton.value);
 				existingWeaponSelected = !!existingWeapon;
 				if(existingWeapon) {
 					weaponSize.checked = ["lg", "huge", "grg"].includes(existingWeapon.system.size);
 					
 					const damageDie = parseInt(existingWeapon.system.damage.die.substring(1))
 						- (existingWeapon.system.equipped.handsHeld >= 2 ? 2 : 0);
 					if(damageDie >= 6) {
 						improvementMap["d6"].checked = true;
 						if(damageDie >= 8) {
 							improvementMap["d8"].checked = true;
 						}
 					}
 					
 					(damageTypes.find((d) => d.value === existingWeapon.system.damage.damageType) ?? damageTypes[0])
 						.checked = true;
 					
 					for(const rule of existingWeapon.system.rules) {
 						if(rule.key === "FlatModifier" && rule.value === 1 && rule.selector?.[0] === "{item|_id}-damage") {
 							improvementMap[rule.damageType].checked = true;
 						}
 					}
 					
 					for(let trait of existingWeapon.system.traits.value) {
 						if(trait.startsWith("deadly")) {
 							trait = "deadly";
 						}
 						if(improvementMap[trait]) {
 							improvementMap[trait].checked = true;
 						}
 					}
 				}
 				
 				//Update the remaining improvements count.
 				onImprovementChange();
 			}
 			
 			for(const weaponButton of weaponSelection) {
 				weaponButton.onchange = onWeaponSelectionChange.bind(this, weaponButton);
 			}
 			
 			onWeaponSelectionChange(Array.from(weaponSelection).find((w) => w.checked));
 		}
 		
 		//Improvements
 		//============
 		
 		function onImprovementChange() {
 			let remaining = IMPROVEMENTS;
 			
 			for(const improvement of improvements) {
 				if(improvement.checked && improvement.offsetParent) {
 					remaining--;
 				}
 			}
 			
 			const s = remaining === 1 || remaining === -1 ? "" : "s";
 			if(remaining < 0) {
 				improvementHeader.textContent = `Remove ${ -remaining } improvement${ s }`;
 			} else {
 				improvementHeader.textContent = `Pick ${ remaining } improvement${ s }`;
 			}
 			
 			if(remaining === 0) {
 				for(const button of confirmButtons) {
 					button.removeAttribute("style");
 				}
 			} else {
 				for(const button of confirmButtons) {
 					button.setAttribute("style", "opacity: 0.3;");
 				}
 			}
 			
 			updateImage();
 		}
 		
 		for(const improvement of improvements) {
 			improvement.onchange = onImprovementChange;
 		}
 		
 		//Preview image
 		//=============
 		
 		function updateImage() {
 			//Ignore d8 unless d6 is checked.
 			const damageDie = improvementMap["d6"].checked ? (improvementMap["d8"].checked ? 8 : 6) : 4;
 			
 			const damageType = damageTypes.find((d) => d.checked)?.value ?? DEFAULT_DAMAGE_TYPE;
 			
 			if(existingWeaponSelected) {
 				//The current selections wouldn't apply.
 			} else if(weaponSize.checked) {
 				switch(damageType) {
 					case "bludgeoning":
 						weaponImage.setAttribute("src", damageDie > 6
 							? "systems/pf2e/icons/equipment/held-items/wheelbarrow.webp"
 							: damageDie > 4
 								? "systems/pf2e/icons/equipment/adventuring-gear/ladder.webp"
 								: "systems/pf2e/icons/equipment/adventuring-gear/chain.webp");
 						break;
 					case "piercing":
 						weaponImage.setAttribute("src", damageDie > 6
 							? "systems/pf2e/icons/equipment/held-items/wand-of-refracting-rays.webp"
 							: damageDie > 4
 								? "systems/pf2e/icons/equipment/other/attached-items/tripod.webp"
 								: "systems/pf2e/icons/equipment/adventuring-gear/long-tool.webp");
 						break;
 					case "slashing":
 						weaponImage.setAttribute("src", damageDie > 6
 							? "systems/pf2e/icons/equipment/snares/bleeding-spines-snare.webp"
 							: damageDie > 4
 								? "systems/pf2e/icons/equipment/held-items/magnetic-construction-set.webp"
 								: "systems/pf2e/icons/equipment/held-items/basic-crutch.webp");
 				}
 			} else {
 				switch(damageType) {
 					case "bludgeoning":
 						weaponImage.setAttribute("src", damageDie > 6
 							? "systems/pf2e/icons/equipment/adventuring-gear/hammer.webp"
 							: damageDie > 4
 								? "systems/pf2e/icons/equipment/adventuring-gear/crowbar.webp"
 								: "systems/pf2e/icons/equipment/adventuring-gear/mug.webp");
 						break;
 					case "piercing":
 						weaponImage.setAttribute("src", damageDie > 6
 							? "systems/pf2e/icons/equipment/adventuring-gear/grapling-hook.webp"
 							: damageDie > 4
 								? "systems/pf2e/icons/equipment/snares/spike-snare.webp"
 								: "systems/pf2e/icons/equipment/held-items/tritons-conch.webp");
 						break;
 					case "slashing":
 						weaponImage.setAttribute("src", damageDie > 6
 							? "systems/pf2e/icons/equipment/adventuring-gear/artisan-tools.webp"
 							: damageDie > 4
 								? "systems/pf2e/icons/equipment/adventuring-gear/piton.webp"
 								: "systems/pf2e/icons/equipment/worn-items/other-worn-items/talisman-cord.webp");
 				}
 			}
 		}
 		
 		weaponSize.onchange = updateImage;
 		for(const damageType of damageTypes) {
 			damageType.onchange = () => {
 				if(damageType.checked) {
 					updateImage();
 				}
 			};
 		}
 		
 		//Initialization
 		//==============
 		
 		if(weaponSelection.length === 0) {
 			//If there's an existing weapon, `onWeaponSelectionChange()` will
 			//have already run `onImprovementChange()`.
 			onImprovementChange();
 		}
 	}
 	
 	const script = scriptFunction.toString();
 	content += "<script>(function scriptFunction() {\n"
 		//Insert constants we'll need.
 		+ `\tconst IMPROVEMENTS = ${ IMPROVEMENTS };\n` //Not a string.
 		+ `\tconst DEFAULT_DAMAGE_TYPE = "${ DEFAULT_DAMAGE_TYPE }";\n`
 		+ `\tconst DEFAULT_WEAPON_SIZE = "${ DEFAULT_WEAPON_SIZE }";\n`
 		+ `\tconst WINDOW_TITLE = "${ WINDOW_TITLE }";\n`
 		+ `\tconst CLASS_WEAPON_IMAGE = "${ CLASS_WEAPON_IMAGE }";\n`
 		+ `\tconst CLASS_SIZE = "${ CLASS_SIZE }";\n`
 		+ `\tconst CLASS_DAMAGE_TYPE = "${ CLASS_DAMAGE_TYPE }";\n`
 		+ `\tconst CLASS_WEAPON_SELECTION = "${ CLASS_WEAPON_SELECTION }";\n`
 		+ `\tconst CLASS_IMPROVEMENT = "${ CLASS_IMPROVEMENT }";\n`
 		+ `\tconst CLASS_IMPROVEMENTS_HEADER = "${ CLASS_IMPROVEMENTS_HEADER }";\n`
 		
 		+ `\tconst ACTOR_ID = "${ actor.id }";\n`
 		
 		//Insert the body of `scriptFunction`.
 		+ script.substring(
 			script.indexOf("{") + 1,
 			script.lastIndexOf("}")) + "\n"
 		
 		+ "})()</script>\n";
 	
 	//Result collection
 	//=================
 	
 	function collectResults(hands, html) {
 		//Check which weapon was selected, if any.
 		let existingWeapon = null;
 		for(const weaponButton of html[0].getElementsByClassName(CLASS_WEAPON_SELECTION)) {
 			if(weaponButton.checked) {
 				existingWeapon = actor.inventory.get(weaponButton.value);
 				break;
 			}
 		}
 		
 		//Get the weapon's base attributes.
 		weapon.name = html[0].getElementsByClassName(CLASS_WEAPON_NAME)[0]?.value ?? DEFAULT_WEAPON_NAME;
 		weapon.system.size = html[0].getElementsByClassName(CLASS_SIZE)[0].checked ? "lg" : "med";
 		for(const damageTypeButton of html[0].getElementsByClassName(CLASS_DAMAGE_TYPE)) {
 			if(damageTypeButton.checked) {
 				weapon.system.damage.damageType = damageTypeButton.value;
 				break;
 			}
 		}
 		
 		if(existingWeapon) {
 			weapon.img = existingWeapon.img;
 			
 			weapon.system.hp.value = existingWeapon.system.hp.value;
 			weapon.system.hp.max = existingWeapon.system.hp.max;
 			weapon.system.hp.brokenThreshold = existingWeapon.system.hp.brokenThreshold;
 		} else {
 			weapon.img = html[0].getElementsByClassName(CLASS_WEAPON_IMAGE)[0]?.getAttribute("src") ?? weapon.img; 
 			
 			if(weapon.system.size !== "med") {
 				weapon.system.hp.value = 40;
 				weapon.system.hp.max = 40;
 				weapon.system.hp.brokenThreshold = 20;
 			}
 		}
 		
 		//Find the improvements.
 		let damageDie = 4;
 		for(const improvement of html[0].getElementsByClassName(CLASS_IMPROVEMENT)) {
 			if(!improvement.checked || !improvement.offsetParent) {
 				continue;
 			}
 			
 			if(improvement.value === "d6" || improvement.value === "d8") {
 				if(damageDie < 8) {
 					damageDie += 2;
 				}
 			} else if(damageTypeOptions.includes(improvement.value)) {
 				weapon.system.rules.push({
 					"damageType": improvement.value,
 					"fromEqiupment": true,
 					"key": "FlatModifier",
 					"label": "Bonus Damage",
 					"selector": "{item|_id}-damage",
 					"value": 1
 				});
 			} else {
 				weapon.system.traits.value.push(improvement.value);
 			}
 		}
 		
 		//Any changes relying on `damageDie` should wait until after the loop.
 		
 		weapon.system.damage.die = "d" + damageDie;
 		weapon.system.traits.value.push("two-hand-d" + (damageDie + 2));
 		
 		weapon.system.bulk.value = damageDie > 4 ? 1 : 0.1;
 		
 		if(weapon.system.traits.value.includes("deadly")) {
 			weapon.system.traits.value[weapon.system.traits.value.indexOf("deadly")]
 				= "deadly-d" + (damageDie + 2);
 		}
 		
 		resolve([true, existingWeapon, hands, damageDie]);
 	}
 	
 	//The window itself
 	//=================
 	
 	new Dialog({
 		title: WINDOW_TITLE,
 		content: content,
 		buttons: {
 			onehand: {
 				//Use `<i></i>` syntax to avoid nesting. `<i />` does not work.
 				label: '<i class="fa-solid fa-wrench fa-flip-horizontal"></i> '
 					+ '<strong>Grab 1-handed</strong>'
 					+ ' <i class="fa-solid fa-wine-bottle fa-flip-horizontal fa-flip-vertical"></i>',
 				callback: collectResults.bind(this, 1)
 			},
 			twohand: {
 				label: '<i class="fa-solid fa-guitar fa-flip-vertical"></i> '
 					+ '<strong>Grab 2-handed</strong>'
 					+ ' <i class="fa-solid fa-baseball-bat-ball"></i>',
 				callback: collectResults.bind(this, 2)
 			}
 		},
 		default: "confirm",
 		close: () => resolve([false])
 	}).render(true);
 });

 if(!ableToContinue) {
 	return;
 }

 //Granting the weapon
 //===================

 //Delete the previous weapon to allow replacing it.
 if(existingWeapon) {
 	await existingWeapon.delete();
 }

 //Create the weapon.
 weapon = (await actor.createEmbeddedDocuments("Item", [weapon]))[0];

 //Grip it with the correct number of hands.
 weapon.update({
 	"system.equipped.carryType": "held",
 	"system.equipped.handsHeld": handsHeld
 });

 //Confirmation message
 //====================

 let posessivePronoun;
 switch(/[a-z]+/.exec(actor.system.details.gender.value?.toLowerCase() ?? "")[0]) {
 	case "he":
 	case "him":
 	case "male":
 	case "masc":
 	case "masculine":
 	case "boy":
 	case "man":
 		posessivePronoun = "his";
 		break;
 	case "she":
 	case "her":
 	case "female":
 	case "fem":
 	case "feminine":
 	case "girl":
 	case "woman":
 		posessivePronoun = "her";
 		break;
 	default:
 		posessivePronoun = "their";
 }

 function joinList(list) {
 	if(list.length >= 2) {
 		list.push("and " + list.pop());
 	}
 	
 	if(list.length >= 3) {
 		return list.join(", ");
 	} else {
 		return list.join(" ");
 	}
 }

 let weaponDescription = existingWeapon
 	? `This weapon now deals `
 	: `This ${ weapon.system.size === "lg" ? "oversize " : "" }weapon deals `;

 const weaponDamageList = [
 	`${ weapon.system.damage.dice }d${ damageDie + (handsHeld > 1 ? 2 : 0) } ${ weapon.system.damage.damageType }`
 ];
 for(const rule of weapon.system.rules) {
 	if(rule.key === "FlatModifier" && rule.selector?.[0] === "{item|_id}-damage") {
 		weaponDamageList.push(rule.value + " " + rule.damageType);
 	}
 }
 weaponDescription += joinList(weaponDamageList) + " damage";

 const weaponTraitList = weapon.system.traits.value.filter((t) => !t.startsWith("two-hand"))
 	.map((trait) => {
 		const traitWords = trait.split("-");
 		
 		for(let i = 0; i < traitWords.length; i++) {
 			traitWords[i] = traitWords[i].charAt(0).toUpperCase() + traitWords[i].substring(1);
 		}
 		
 		const traitForDisplay = traitWords.join(" ");
 		
 		if(/-(?:\d+|d\d+|[bps])$/.test(trait)) {
 			traitWords.pop();
 		}
 		
 		const traitTooltip = "PF2E.TraitDescription" + traitWords.join("");
 		
 		return `<span data-trait="${ trait }" data-tooltip="${ traitTooltip }">${ traitForDisplay }</span>`;
 	});
 if(weaponTraitList.length > 0) {
 	weaponDescription += ', and has the <span data-tooltip-class="pf2e">'
 		+ joinList(weaponTraitList)
 		+ "</span> trait" + (weaponTraitList.length > 1 ? "s" : "");
 }

 weaponDescription += ".";

 const weaponName = weapon.name === DEFAULT_WEAPON_NAME
 	? DEFAULT_WEAPON_NAME.toLowerCase()
 	: weapon.name.toLowerCase().replace("improvised ", "");

 const traitsExceptTwoHand = weapon.system.traits.value.filter((t) => !t.startsWith("two-hand"));
 await ChatMessage.create({
 	type: 3,
 	user: game.user._id,
 	speaker: ChatMessage.getSpeaker({ token: actor }),
 	flavor: '<h4 class="action"><strong>Improvise a weapon</strong> <span class="action-glyph">1</span></h4>'
 		+ '<div class="tags paizo-style" data-tooltip-class="pf2e"><span class="tag" data-slug="manipulate" data-tooltip="PF2E.TraitDescriptionManipulate">Manipulate</span></div>'
 		+ '<hr class="action-divider">',
 	content: '<p class="action-content">'
 		+ `<img src="${ weapon.img }">`
 		+ "<span>"
 		+ (existingWeapon
 			? `${ actor.name } shifts ${ posessivePronoun } grip on ${ posessivePronoun } ${ weaponName }, holding it in ${ handsHeld > 1 ? "both hands" : "one hand" }. `
 			: `${ actor.name } picks up ${ /^[aeiou]/i.test(weaponName) ? "an" : "a" } ${ weaponName } in ${ handsHeld > 1 ? "both hands" : "one hand" }. `)
 		+ "</span></p>"
 		+ `<span>${ weaponDescription }</span>`
 });