1763 lines
70 KiB
JavaScript
1763 lines
70 KiB
JavaScript
import { SLAMothershipGenerator } from "../windows/sla-character-generator.js";
|
||
import { SLADrugSystem } from "../sla-drug-system.js";
|
||
import { buildSlaTraitRows, getSlaTraitOptionsByType, validateSlaTraitRows } from "../traits/sla-traits.js";
|
||
|
||
function isEbbSkillName(name = "") {
|
||
const clean = String(name ?? "").trim();
|
||
return clean.startsWith("Ebb ") || ["Biofeedback", "Formulate", "Ebb (Core)"].includes(clean);
|
||
}
|
||
|
||
function sortSkillCollection(skills = []) {
|
||
return [...skills].sort((left, right) => {
|
||
const leftCategory = String(left?.system?.sla?.category ?? "").trim().toLowerCase();
|
||
const rightCategory = String(right?.system?.sla?.category ?? "").trim().toLowerCase();
|
||
if (leftCategory !== rightCategory) return leftCategory.localeCompare(rightCategory);
|
||
return String(left?.name ?? "").localeCompare(String(right?.name ?? ""));
|
||
});
|
||
}
|
||
|
||
function dedupeSkillCollection(skills = []) {
|
||
const byName = new Map();
|
||
for (const skill of skills) {
|
||
const key = String(skill?.name ?? "").trim().toLowerCase();
|
||
if (!key) continue;
|
||
const current = byName.get(key);
|
||
const currentBonus = Number(current?.system?.bonus ?? 0) || 0;
|
||
const nextBonus = Number(skill?.system?.bonus ?? 0) || 0;
|
||
if (!current || nextBonus > currentBonus) {
|
||
byName.set(key, skill);
|
||
}
|
||
}
|
||
return Array.from(byName.values());
|
||
}
|
||
|
||
function normalizeTraitSkillKey(value = "") {
|
||
return String(value ?? "")
|
||
.toLowerCase()
|
||
.replace(/[^a-z0-9]+/g, "");
|
||
}
|
||
|
||
function roundCarryWeight(value) {
|
||
return Math.round((Number(value ?? 0) || 0) * 10) / 10;
|
||
}
|
||
|
||
function encToKg(enc) {
|
||
return roundCarryWeight((Number(enc ?? 0) || 0) * 1.5);
|
||
}
|
||
|
||
function resolveItemWeight(itemDoc) {
|
||
const system = itemDoc?.system ?? {};
|
||
const explicitWeight = Number(system.weight ?? 0);
|
||
const encValue = Number(system?.sla?.enc ?? 0);
|
||
if ((itemDoc?.type === "weapon" || itemDoc?.type === "armor") && encValue > 0) {
|
||
if (explicitWeight <= 0 || Math.abs(explicitWeight - encValue) < 0.001) {
|
||
return encToKg(encValue);
|
||
}
|
||
}
|
||
return roundCarryWeight(explicitWeight);
|
||
}
|
||
|
||
function getCarryState(itemDoc) {
|
||
const system = itemDoc?.system ?? {};
|
||
if (system.carryState) return String(system.carryState);
|
||
if (itemDoc?.type === "armor" && system.equipped) return "equipped";
|
||
return "carried";
|
||
}
|
||
|
||
function buildCarryStateMeta(itemDoc) {
|
||
const state = getCarryState(itemDoc);
|
||
return {
|
||
state,
|
||
label: state === "equipped" ? "Equipped" : state === "stowed" ? "Stowed" : "Carried",
|
||
cssClass: state === "equipped" ? "equipped" : state === "stowed" ? "stowed" : "carried",
|
||
countsWeight: state !== "stowed"
|
||
};
|
||
}
|
||
|
||
function calculateCarryCapacity(actorSystem = {}) {
|
||
const strength = Math.max(0, Number(actorSystem?.stats?.strength?.value ?? 0) || 0);
|
||
const body = Math.max(0, Number(actorSystem?.stats?.body?.value ?? 0) || 0);
|
||
return roundCarryWeight(Math.max(10, (strength * 0.6) + (body * 0.4)));
|
||
}
|
||
|
||
function buildTraitSkillPreview(traitRows = [], skillName = "") {
|
||
const key = normalizeTraitSkillKey(skillName);
|
||
const communicationSkills = new Set(["command", "fasttalk", "intimidate", "persuade", "streetwise"]);
|
||
const effects = [];
|
||
let flatMod = 0;
|
||
|
||
const add = (amount, label) => {
|
||
const value = Number(amount ?? 0) || 0;
|
||
if (!value) return;
|
||
flatMod += value;
|
||
effects.push(`${label}: ${value >= 0 ? "+" : ""}${value}%`);
|
||
};
|
||
|
||
for (const row of traitRows) {
|
||
const rank = Math.max(1, Number(row?.slaTrait?.rank ?? 1) || 1);
|
||
switch (String(row?.slaTrait?.key ?? "")) {
|
||
case "good-hearing":
|
||
if (key === "listen") add(10 * rank, row.name);
|
||
break;
|
||
case "poor-hearing":
|
||
if (key === "listen") add(-10 * rank, row.name);
|
||
break;
|
||
case "good-vision":
|
||
if (key === "spothidden") add(10 * rank, row.name);
|
||
break;
|
||
case "poor-vision":
|
||
if (key === "spothidden") add(-10 * rank, row.name);
|
||
break;
|
||
case "attractive":
|
||
if (communicationSkills.has(key)) add(10 * rank, row.name);
|
||
break;
|
||
case "unattractive":
|
||
if (communicationSkills.has(key)) add(-10 * rank, row.name);
|
||
break;
|
||
case "depression":
|
||
if (communicationSkills.has(key)) add(-10 * rank, row.name);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
return {
|
||
flatMod,
|
||
effects,
|
||
summary: effects.join(" | "),
|
||
modLabel: flatMod ? `${flatMod > 0 ? "+" : ""}${flatMod}` : ""
|
||
};
|
||
}
|
||
|
||
function decorateSkillWithTraitPreview(skill, traitRows = []) {
|
||
skill.system ??= {};
|
||
const baseBonus = Number(skill.system.bonus ?? 0) || 0;
|
||
const preview = buildTraitSkillPreview(traitRows, skill.name);
|
||
skill.system.displayBonus = baseBonus + preview.flatMod;
|
||
skill.system.traitMod = preview.flatMod;
|
||
skill.system.traitEffects = preview.effects;
|
||
skill.slaTraitPreview = preview;
|
||
return skill;
|
||
}
|
||
|
||
function getPurchasableItemTotalCost(itemData = {}) {
|
||
const system = itemData?.system ?? itemData?.data ?? {};
|
||
const unitCost = Number(system.cost ?? 0) || 0;
|
||
const quantity = Math.max(1, Number(system.quantity ?? 1) || 1);
|
||
return Math.round(unitCost * quantity * 100) / 100;
|
||
}
|
||
|
||
function isAmmoPurchaseItem(itemData = {}) {
|
||
const system = itemData?.system ?? itemData?.data ?? {};
|
||
const sla = system?.sla ?? {};
|
||
const name = String(itemData?.name ?? "").trim().toLowerCase();
|
||
const category = String(sla.category ?? "").trim().toLowerCase();
|
||
const calibre = String(sla.calibre ?? "").trim();
|
||
const ammoTag = String(sla.ammoTag ?? "").trim();
|
||
return category === "ammunition" || Boolean((calibre && ammoTag) || name.startsWith("ammo:"));
|
||
}
|
||
|
||
function formatSlaTimestamp() {
|
||
return new Intl.DateTimeFormat(undefined, {
|
||
dateStyle: "short",
|
||
timeStyle: "short"
|
||
}).format(new Date());
|
||
}
|
||
|
||
const SLA_SPECIES_RULES = {
|
||
Human: [
|
||
{ key: "adaptable", label: "Adaptable", summary: "Once per session, reroll one Stat check and take the better result.", optional: false, default: true }
|
||
],
|
||
Frother: [
|
||
{ key: "berserkState", label: "Berserk State", summary: "On a failed Sanity Save, the Frother may enter Berserk instead of gaining Stress: +10 to Combat and Strength checks, but risks attacking the nearest target.", optional: true, default: true },
|
||
{ key: "drugMetabolism", label: "Drug Metabolism", summary: "No addiction roll for standard combat drugs, and one combat drug per scene can be taken without a Body Save penalty.", optional: true, default: true }
|
||
],
|
||
Ebon: [
|
||
{ key: "ebbSensitivity", label: "Ebb Sensitivity", summary: "Automatically senses nearby Ebb use and rolls Sanity Saves at Disadvantage against reality-warping events.", optional: false, default: true },
|
||
{ key: "fluxPool", label: "Flux Pool", summary: "Flux begins at Intellect / 4 with a minimum reserve of 20, and recovers at 1 point per hour of rest.", optional: false, default: true }
|
||
],
|
||
"Brain Waster": [
|
||
{ key: "ebbAggression", label: "Ebb Aggression", summary: "Damaging Ebb abilities add +1d5 damage.", optional: false, default: true },
|
||
{ key: "unnervingPresence", label: "Unnerving Presence", summary: "Nearby allies roll Fear Saves at Disadvantage when the Brain Waster channels Ebb.", optional: true, default: true }
|
||
],
|
||
"Wraith Raider": [
|
||
{ key: "predatorSenses", label: "Predator Senses", summary: "Advantage on Speed-based perception, ambush detection, and initiative checks. Never surprised in natural or urban environments unless by supernatural means.", optional: false, default: true },
|
||
{ key: "naturalWeapons", label: "Natural Weapons", summary: "Claws deal Strength / 10 + 1d5 damage at Adjacent range and count as primary species weapons.", optional: false, default: true }
|
||
],
|
||
Shaktar: [
|
||
{ key: "honourBound", label: "Honour Bound", summary: "Breaking a code of honour forces a Sanity Save or the Shaktar gains 1d3 Stress.", optional: true, default: true },
|
||
{ key: "naturalWeapons", label: "Natural Weapons", summary: "Claws deal Strength / 10 damage and grappling or restraining Strength checks gain Advantage.", optional: false, default: true }
|
||
],
|
||
"Stormer 313 Malice": [
|
||
{ key: "prometheusRegeneration", label: "Prometheus Regeneration", summary: "At the end of every fourth combat round, recover 1d5 Health. Once wounds are healed, continue recovering 1 Health per round.", optional: true, default: true },
|
||
{ key: "biogeneticAggression", label: "Biogenetic Aggression", summary: "Disadvantage on Intellect checks involving diplomacy, deception detection, or abstract reasoning.", optional: false, default: true },
|
||
{ key: "financeChipMandatory", label: "Finance Chip Mandatory", summary: "The Karma finance chip is built in and cannot be removed.", optional: false, default: true }
|
||
],
|
||
"Stormer 711 Xeno": [
|
||
{ key: "chameleonChitin", label: "Chameleon Chitin", summary: "Spend 1 action to become near-invisible while stationary. Detection is at Disadvantage until the Xeno moves.", optional: true, default: true },
|
||
{ key: "prometheusRegeneration", label: "Prometheus Regeneration", summary: "At the end of every fourth combat round, recover 1d5 Health.", optional: true, default: true },
|
||
{ key: "inhumanAppearance", label: "Inhuman Appearance", summary: "Social Intellect checks against other species are at Disadvantage because the Xeno is deeply unnerving.", optional: true, default: true }
|
||
],
|
||
"Advanced Carrien": [
|
||
{ key: "socialPrejudice", label: "Social Prejudice", summary: "Track district or sponsor prejudice penalties until a source-grounded Carrien conversion replaces this draft entry.", optional: true, default: true }
|
||
]
|
||
};
|
||
|
||
/**
|
||
* Extend the basic ActorSheet with some very simple modifications
|
||
* @extends {ActorSheet}
|
||
*/
|
||
export class MothershipActorSheet extends foundry.appv1.sheets.ActorSheet {
|
||
|
||
constructor(...args) {
|
||
super(...args);
|
||
this._slaTraitPickerSelection ??= {
|
||
advantage: "",
|
||
disadvantage: ""
|
||
};
|
||
}
|
||
|
||
/** @override */
|
||
static get defaultOptions() {
|
||
var options = {
|
||
classes: ["mosh", "sheet", "actor", "character"],
|
||
template: "systems/sla-mothership/templates/actor/actor-sheet.html",
|
||
width: 820,
|
||
height: 820,
|
||
tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "skills" }],
|
||
submitOnChange: true
|
||
}
|
||
return foundry.utils.mergeObject(super.defaultOptions, options);
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
|
||
/** @override */
|
||
async getData() {
|
||
const data = await super.getData();
|
||
|
||
data.dtypes = ["String", "Number", "Boolean"];
|
||
|
||
const superData = data.data.system;
|
||
|
||
for (let attr of Object.values(data.data.system.attributes)) {
|
||
attr.isCheckbox = attr.dtype === "Boolean";
|
||
}
|
||
|
||
// Prepare items.
|
||
if (this.actor.type == 'character') {
|
||
this._prepareCharacterItems(data);
|
||
}
|
||
|
||
|
||
if (data.data.system.settings == null) {
|
||
data.data.system.settings = {};
|
||
}
|
||
data.data.system.settings.useCalm = game.settings.get("sla-mothership", "useCalm");
|
||
data.data.system.settings.hideWeight = game.settings.get("sla-mothership", "hideWeight");
|
||
data.data.system.settings.firstEdition = game.settings.get("sla-mothership", "firstEdition");
|
||
data.data.system.settings.androidPanic = game.settings.get("sla-mothership", "androidPanic");
|
||
|
||
superData.sla ??= {};
|
||
superData.sla.operativeType ??= { value: "" };
|
||
superData.sla.species ??= { value: "" };
|
||
superData.sla.speciesNotes ??= { value: "" };
|
||
superData.sla.trainingPackage ??= { value: "" };
|
||
superData.sla.packageSummary ??= { value: "" };
|
||
superData.sla.packageSkills ??= { value: "" };
|
||
superData.sla.packageWealth ??= { value: "" };
|
||
superData.sla.flux ??= { value: 0, min: 0, max: 0, label: "Flux" };
|
||
superData.sla.fluxStage ??= { value: "" };
|
||
superData.sla.bpn ??= { value: "" };
|
||
superData.sla.scl ??= { value: "" };
|
||
superData.sla.employer ??= { value: "" };
|
||
superData.sla.sector ??= { value: "" };
|
||
superData.sla.height ??= { value: "" };
|
||
superData.sla.weightText ??= { value: "" };
|
||
superData.sla.lad ??= false;
|
||
superData.sla.ebbRating ??= { value: 0 };
|
||
superData.sla.ammoSpendTotal ??= { value: 0 };
|
||
superData.sla.ammoLedger ??= { value: "" };
|
||
superData.sla.fluxNotes ??= { value: "" };
|
||
superData.sla.ebbNotes ??= { value: "" };
|
||
superData.sla.speciesRules ??= {};
|
||
superData.sla.sessionAbilityUsed ??= false;
|
||
superData.sla.contacts ??= [];
|
||
superData.sla.activityLog ??= { value: "" };
|
||
const activeTheme = this.actor.getFlag("sla-mothership", "sheetTheme") || "modern";
|
||
data.slaSheetTheme = activeTheme;
|
||
data.data.slaSheetTheme = activeTheme;
|
||
|
||
data.data.enriched = [];
|
||
data.data.enriched.notes = await foundry.applications.ux.TextEditor.implementation.enrichHTML(superData.notes, {async: true});
|
||
data.data.enriched.biography = await foundry.applications.ux.TextEditor.implementation.enrichHTML(superData.biography, {async: true});
|
||
data.data.isEbbUser = this.actor.isSlaEbbUser?.() ?? false;
|
||
data.data.slaFlux = this.actor.getSlaFluxState?.() ?? { label: "Stable", description: "", cssClass: "stable", thresholds: "25% / 50% / 75% / 100%" };
|
||
data.data.slaFluxGuidance = this.actor.getSlaFluxGuidance?.() ?? [];
|
||
const fluxValue = Number(superData.sla.flux?.value ?? 0);
|
||
const fluxMax = Math.max(0, Number(superData.sla.flux?.max ?? 0));
|
||
data.data.slaFluxPercent = fluxMax > 0 ? Math.min(100, Math.max(0, Math.round((fluxValue / fluxMax) * 100))) : 0;
|
||
// Vevaphon morph data
|
||
data.data.isVevaphon = this.actor.isSlaVevaphon?.() ?? false;
|
||
if (data.data.isVevaphon) {
|
||
const instab = Math.max(0, Math.min(12, Number(superData.sla.vevaphonInstability?.value ?? 0) || 0));
|
||
data.data.vevaphonInstabilityPercent = Math.round((instab / 12) * 100);
|
||
data.data.vevaphonInstabilityElevated = instab >= 6;
|
||
data.data.vevaphonInstabilityCritical = instab >= 10;
|
||
data.data.vevaphonInstabilityClass = instab >= 10 ? "instability-critical" : instab >= 6 ? "instability-elevated" : "instability-nominal";
|
||
data.data.vevaphonInstabilityDesc = instab >= 10
|
||
? "Instability critical. Full reversion risk on every shift."
|
||
: instab >= 6
|
||
? "Instability elevated. Sanity saves required when morphing mid-scene."
|
||
: "Instability nominal. Morphing is available without additional risk.";
|
||
data.data.vevaphonMorphPanic = [
|
||
{ roll: 1, label: "Cascade Shift", desc: "Random morph form, +1 Instability." },
|
||
{ roll: 2, label: "Identity Bleed", desc: "Forgets name and callsign until end of scene." },
|
||
{ roll: 3, label: "Partial Lock", desc: "One limb freezes. −10 physical rolls using that limb." },
|
||
{ roll: 4, label: "Tissue Rejection", desc: "1d5 damage, armour does not apply." },
|
||
{ roll: 5, label: "Threat Imprint", desc: "Locked on nearest visible target." },
|
||
{ roll: 6, label: "Full Reversion", desc: "Base form, lose morph bonuses, −1 Instability." }
|
||
];
|
||
}
|
||
data.data.slaSpeciesTraitList = String(superData.sla.speciesNotes?.value ?? "").split(/\n+/).map((entry) => entry.trim()).filter(Boolean);
|
||
data.data.slaPackageSkillList = String(superData.sla.packageSkills?.value ?? "").split(/\s*,\s*/).map((entry) => entry.trim()).filter(Boolean);
|
||
data.data.slaSpeciesRules = getSpeciesRules(String(superData.sla.species?.value ?? "").trim(), superData.sla.speciesRules);
|
||
data.data.slaEnabledSpeciesRules = data.data.slaSpeciesRules.filter((rule) => rule.enabled);
|
||
data.data.slaEnabledSpeciesRuleCount = data.data.slaEnabledSpeciesRules.length;
|
||
data.data.slaPositiveTraitOptions = getSlaTraitOptionsByType("advantage");
|
||
data.data.slaNegativeTraitOptions = getSlaTraitOptionsByType("disadvantage");
|
||
data.data.slaTraitPickerSelection = {
|
||
advantage: String(this._slaTraitPickerSelection?.advantage ?? "").trim(),
|
||
disadvantage: String(this._slaTraitPickerSelection?.disadvantage ?? "").trim()
|
||
};
|
||
data.data.slaPrometheusStatus = this.actor.getSlaPrometheusStatus?.() ?? { enabled: false, inCombat: false, currentRound: 0, roundsUntilPulse: null, pulseThisRound: false };
|
||
|
||
// Contacts
|
||
const rawContacts = Array.isArray(superData.sla.contacts) ? superData.sla.contacts : [];
|
||
data.data.slaContacts = rawContacts.map((c) => ({
|
||
id: String(c.id ?? foundry.utils.randomID()),
|
||
name: String(c.name ?? "Unknown"),
|
||
role: String(c.role ?? ""),
|
||
notes: String(c.notes ?? ""),
|
||
disposition: ["ally", "neutral", "hostile", "unknown"].includes(c.disposition) ? c.disposition : "neutral"
|
||
}));
|
||
data.data.slaContactCount = data.data.slaContacts.length;
|
||
const traitRows = buildSlaTraitRows(data.data.persTraits ?? []);
|
||
data.data.persTraitsEnhanced = traitRows;
|
||
data.data.traitCount = traitRows.length;
|
||
data.data.traitValidation = validateSlaTraitRows(traitRows);
|
||
data.data.skills = sortSkillCollection(dedupeSkillCollection((data.data.skills ?? []).map((skill) => {
|
||
const breakdown = this.actor.getSkillBreakdown?.(skill) ?? {};
|
||
skill.system ??= {};
|
||
skill.system.sla ??= {};
|
||
skill.system.sla.category ||= breakdown.category ?? "";
|
||
skill.slaBreakdown = breakdown;
|
||
skill.isEbbSkill = isEbbSkillName(skill.name);
|
||
skill.isCombatSkill = Boolean(skill.system.sla.combat);
|
||
return decorateSkillWithTraitPreview(skill, traitRows);
|
||
})));
|
||
data.data.ebbSkills = sortSkillCollection(dedupeSkillCollection((data.data.ebbSkills ?? []).map((skill) => {
|
||
const breakdown = this.actor.getSkillBreakdown?.(skill) ?? {};
|
||
skill.system ??= {};
|
||
skill.system.sla ??= {};
|
||
skill.system.sla.category ||= breakdown.category ?? "";
|
||
skill.slaBreakdown = breakdown;
|
||
skill.isEbbSkill = true;
|
||
skill.isCombatSkill = Boolean(skill.system.sla.combat);
|
||
return decorateSkillWithTraitPreview(skill, traitRows);
|
||
})));
|
||
const drugOverview = await SLADrugSystem.getActorOverview(this.actor);
|
||
data.data.drugAlerts = drugOverview.alerts;
|
||
data.data.drugRows = (drugOverview.rows ?? []).map((row) => {
|
||
const sourceItem = this.actor.items.get(row.itemId);
|
||
const carryMeta = sourceItem ? buildCarryStateMeta(sourceItem) : { state: "carried", label: "Carried", cssClass: "carried", countsWeight: true };
|
||
const totalWeight = sourceItem
|
||
? roundCarryWeight(resolveItemWeight(sourceItem) * Math.max(1, Number(sourceItem.system?.quantity ?? row.quantity ?? 1) || 1))
|
||
: 0;
|
||
return {
|
||
...row,
|
||
slaCarry: {
|
||
...carryMeta,
|
||
totalWeight
|
||
}
|
||
};
|
||
});
|
||
data.data.slaStatModifierTitles = SLADrugSystem.getStatModifierTitles(this.actor);
|
||
const ammoItems = Array.from(this.actor.items ?? []).filter((item) =>
|
||
item.type === "item" && String(item.system?.sla?.category ?? "").trim().toLowerCase() === "ammunition"
|
||
);
|
||
data.data.slaAmmoInventory = {
|
||
stackCount: ammoItems.length,
|
||
roundCount: ammoItems.reduce((total, item) => total + (Number(item.system?.quantity ?? 0) || 0), 0)
|
||
};
|
||
data.data.slaCarry = {
|
||
capacity: roundCarryWeight(Number(superData.weight?.capacity ?? 0) || 0),
|
||
current: roundCarryWeight(Number(superData.weight?.current ?? 0) || 0),
|
||
equipped: roundCarryWeight(Number(superData.weight?.equipped ?? 0) || 0),
|
||
carried: roundCarryWeight(Number(superData.weight?.carried ?? 0) || 0),
|
||
stowed: roundCarryWeight(Number(superData.weight?.stowed ?? 0) || 0),
|
||
available: roundCarryWeight(Number(superData.weight?.available ?? 0) || 0),
|
||
over: Boolean(superData.weight?.over),
|
||
state: String(superData.weight?.state ?? "Nominal")
|
||
};
|
||
|
||
|
||
//SKILL XP BUTTONS
|
||
superData.xp.html = '';
|
||
if (superData.xp.html == '') {
|
||
for (let i = 1; i <= 15; i++) {
|
||
if (i > superData.xp.value) {
|
||
if (i % 5) {
|
||
superData.xp.html += '<div class="circle"></div>';
|
||
}
|
||
else { //If a special one
|
||
let trainLevel = '<div class="skill_training_text" style="position: relative; top: 17px; text-align: center; left: -54px;">Trained</div>';
|
||
if (i == 10) trainLevel = '<div class="skill_training_text" style="position: relative; top: 17px; text-align: center; left: -50px;">Expert</div>';
|
||
else if (i == 15) trainLevel = '<div class="skill_training_text" style="position: relative; top: 17px; text-align: center; left: -52px;">Master</div>';
|
||
superData.xp.html += '<div class="circle" style="background:rgb(200,200,200);">' + trainLevel + '</div>';
|
||
}
|
||
}
|
||
else {
|
||
if (i % 5) {
|
||
superData.xp.html += '<div class="circle-f"></div>';
|
||
}
|
||
else { //If a special one
|
||
let trainLevel = '<div class="skill_training_text" style="position: relative; top: 17px; text-align: center; left: -54px; color:black;">Trained</div>';
|
||
if (i == 10) trainLevel = '<div class="skill_training_text" style="position: relative; top: 17px; text-align: center; left: -50px; color:black;">Expert</div>';
|
||
else if (i == 15) trainLevel = '<div class="skill_training_text" style="position: relative; top: 17px; text-align: center; left: -52px; color:black;">Master</div>';
|
||
superData.xp.html += '<div class="circle-f" style="background:black;">' + trainLevel + '</div>';
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
//END SKILL XP
|
||
|
||
return data.data;
|
||
}
|
||
|
||
/**
|
||
* Organize and classify Items for Character sheets.
|
||
*
|
||
* @param {Object} actorData The actor to prepare.
|
||
*
|
||
* @return {undefined}
|
||
*/
|
||
_prepareCharacterItems(sheetData) {
|
||
const actorData = sheetData.data;
|
||
//console.log(sheetData);
|
||
///console.log("sheetdata Above");
|
||
// Initialize containers.
|
||
const gear = [];
|
||
const drugs = [];
|
||
const skills = [];
|
||
const ebbSkills = [];
|
||
const weapons = [];
|
||
const armors = [];
|
||
const conditions = [];
|
||
const abilities = [];
|
||
const morphForms = [];
|
||
const persTraits = [];
|
||
|
||
let curWeight = 0;
|
||
let equippedWeight = 0;
|
||
let carriedWeight = 0;
|
||
let stowedWeight = 0;
|
||
// Iterate through items, allocating to containers
|
||
// let totalWeight = 0;
|
||
for (let i of sheetData.items) {
|
||
let item = i.system;
|
||
i.img = i.img || DEFAULT_TOKEN;
|
||
const resolvedWeight = resolveItemWeight(i);
|
||
const carryMeta = buildCarryStateMeta(i);
|
||
const quantity = Math.max(1, Number(item.quantity ?? 1) || 1);
|
||
item.weightResolved = resolvedWeight;
|
||
item.carryState ??= carryMeta.state;
|
||
i.slaCarry = {
|
||
...carryMeta,
|
||
weight: resolvedWeight,
|
||
totalWeight: roundCarryWeight(resolvedWeight * quantity)
|
||
};
|
||
if (carryMeta.state === "equipped") equippedWeight += i.slaCarry.totalWeight;
|
||
else if (carryMeta.state === "stowed") stowedWeight += i.slaCarry.totalWeight;
|
||
else carriedWeight += i.slaCarry.totalWeight;
|
||
|
||
if (i.type === 'item') {
|
||
gear.push(i);
|
||
if (carryMeta.countsWeight) curWeight += i.slaCarry.totalWeight;
|
||
} else if (i.type === 'drug') {
|
||
drugs.push(i);
|
||
if (carryMeta.countsWeight) curWeight += i.slaCarry.totalWeight;
|
||
} else if (i.type === 'skill') {
|
||
if (isEbbSkillName(i.name)) {
|
||
ebbSkills.push(i);
|
||
} else {
|
||
skills.push(i);
|
||
}
|
||
} else if (i.type === 'armor') {
|
||
armors.push(i);
|
||
if (carryMeta.countsWeight) curWeight += i.slaCarry.totalWeight;
|
||
} else if (i.type === 'weapon') {
|
||
//We need to update this from the old system.
|
||
item.ranges ??= { short: 0, medium: 0, long: 0, value: "" };
|
||
if (item.ranges.value == "" && item.ranges.medium > 0) {
|
||
item.ranges.value = item.ranges.short + "/" + item.ranges.medium + "/" + item.ranges.long;
|
||
item.ranges.medium = 0;
|
||
}
|
||
item.sla ??= {};
|
||
if (item.useAmmo) {
|
||
item.ammoTag ??= "STD";
|
||
item.ammoLoadedType ??= item.ammoTag ?? "STD";
|
||
item.ammoCalibre ??= item.ammoType ?? "";
|
||
item.ammoReserveStd ??= Math.max(0, Number(item.ammo ?? 0) || 0);
|
||
item.ammoReserveAp ??= 0;
|
||
item.ammoReserveHe ??= 0;
|
||
item.ammoReserveHeap ??= 0;
|
||
item.ammoReserve = getAmmoReserveTotal(item);
|
||
item.sla.fireModes ??= deriveWeaponFireModes(item);
|
||
item.sla.currentFireMode ??= parseWeaponFireModes(item.sla.fireModes)[0]?.label ?? "Single";
|
||
item.shotsPerFire = getActiveFireMode(item)?.shots ?? Math.max(Number(item.shotsPerFire ?? 1) || 1, 1);
|
||
const ammoInventory = summarizeWeaponAmmoInventory(this.actor, item);
|
||
item.sla.ammoChoices = ammoInventory.choices;
|
||
item.sla.ammoReserve = ammoInventory.total;
|
||
item.sla.loadedAmmoLabel = item.ammoLoadedType ?? "STD";
|
||
item.sla.loadedAmmoReserve = ammoInventory.byTag[item.ammoLoadedType ?? "STD"] ?? ammoInventory.total;
|
||
item.sla.loadedAmmoSummary = `${item.sla.loadedAmmoLabel} | ${item.sla.loadedAmmoReserve} carried`;
|
||
item.sla.calibreLabel = item.ammoCalibre || item.ammoType || "Unknown calibre";
|
||
const currentShots = Math.max(0, Number(item.curShots ?? 0) || 0);
|
||
const maxShots = Math.max(0, Number(item.shots ?? 0) || 0);
|
||
if (currentShots <= 0) {
|
||
item.sla.ammoState = "Empty";
|
||
item.sla.ammoStateClass = "empty";
|
||
} else if (maxShots && currentShots <= Math.ceil(maxShots / 3)) {
|
||
item.sla.ammoState = "Low";
|
||
item.sla.ammoStateClass = "low";
|
||
} else {
|
||
item.sla.ammoState = "Ready";
|
||
item.sla.ammoStateClass = "ready";
|
||
}
|
||
item.sla.reserveSummary = `${currentShots}/${maxShots} loaded | ${item.sla.loadedAmmoReserve} spare`;
|
||
}
|
||
|
||
weapons.push(i);
|
||
if (carryMeta.countsWeight) curWeight += i.slaCarry.totalWeight;
|
||
} else if (i.type === 'condition') {
|
||
// We'll handle the pip html here.
|
||
if (item.treatment == null) {
|
||
item.treatment = {
|
||
"value": 0,
|
||
"html": ""
|
||
};
|
||
}
|
||
let pipHtml = "";
|
||
for (let i = 0; i < 3; i++) {
|
||
if (i < item.treatment.value) {
|
||
pipHtml += '<i class="fas fa-circle"></i>';
|
||
}
|
||
else {
|
||
pipHtml += '<i class="far fa-circle"></i>';
|
||
}
|
||
}
|
||
|
||
item.treatment.html = pipHtml;
|
||
|
||
conditions.push(i);
|
||
} else if (i.type === 'ability') {
|
||
if (i.system?.sla?.morphForm) {
|
||
morphForms.push(i);
|
||
} else {
|
||
abilities.push(i);
|
||
}
|
||
} else if (i.type === 'persTrait') {
|
||
persTraits.push(i);
|
||
}
|
||
}
|
||
|
||
if (actorData.system.weight == undefined) {
|
||
actorData.system.weight = {
|
||
"current": 0,
|
||
"capacity": 0
|
||
};
|
||
}
|
||
if (actorData.system.credits == undefined) {
|
||
actorData.system.credits = {
|
||
"value": 0,
|
||
};
|
||
}
|
||
|
||
actorData.system.weight.capacity = calculateCarryCapacity(actorData.system);
|
||
actorData.system.weight.current = roundCarryWeight(curWeight);
|
||
actorData.system.weight.equipped = roundCarryWeight(equippedWeight);
|
||
actorData.system.weight.carried = roundCarryWeight(carriedWeight);
|
||
actorData.system.weight.stowed = roundCarryWeight(stowedWeight);
|
||
actorData.system.weight.available = roundCarryWeight(actorData.system.weight.capacity - actorData.system.weight.current);
|
||
actorData.system.weight.over = actorData.system.weight.current > actorData.system.weight.capacity;
|
||
actorData.system.weight.state = actorData.system.weight.over ? "Overloaded" : actorData.system.weight.current > actorData.system.weight.capacity * 0.8 ? "Near Limit" : "Nominal";
|
||
//console.log("Current Weight: " + curWeight + " Capacity: " + actorData.data.weight.capacity);
|
||
|
||
// Assign and return
|
||
actorData.gear = gear;
|
||
actorData.drugs = drugs;
|
||
actorData.skills = skills;
|
||
actorData.ebbSkills = ebbSkills;
|
||
actorData.armors = armors;
|
||
actorData.weapons = weapons;
|
||
actorData.conditions = conditions;
|
||
actorData.abilities = abilities;
|
||
const activeMorphFormName = String(actorData.system?.sla?.morphForm?.value ?? "").trim();
|
||
morphForms.forEach(f => { f.slaIsActiveMorphForm = f.name === activeMorphFormName; });
|
||
actorData.slaMorphForms = morphForms;
|
||
actorData.persTraits = persTraits.sort((left, right) => String(left?.name ?? "").localeCompare(String(right?.name ?? "")));
|
||
|
||
}
|
||
|
||
/** @override */
|
||
activateListeners(html) {
|
||
super.activateListeners(html);
|
||
this._applyThemeClasses(html);
|
||
|
||
// Everything below here is only needed if the sheet is editable
|
||
if (!this.options.editable) return;
|
||
|
||
html.on('mousedown', '.char-pip-button', ev => {
|
||
|
||
const div = $(ev.currentTarget);
|
||
const targetName = div.data("key");
|
||
|
||
let amount = this.actor.system.xp.value;
|
||
let newAmount = amount;
|
||
let max = div.data("max");
|
||
let min = div.data("min");
|
||
|
||
if (event.button == 0) {
|
||
if (amount < max) {
|
||
newAmount = Number(amount) + 1;
|
||
}
|
||
} else if (event.button == 2) {
|
||
if (amount > min) {
|
||
newAmount = Number(amount) - 1;
|
||
}
|
||
}
|
||
|
||
this.actor.update({'system.xp.value': newAmount});
|
||
|
||
});
|
||
|
||
html.on('mousedown', '.treatment-button', ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
//const item = duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId))
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
|
||
|
||
let amount = item.system.treatment.value;
|
||
|
||
if (event.button == 0) {
|
||
if (amount < 3) {
|
||
item.system.treatment.value = Number(amount) + 1;
|
||
}
|
||
} else if (event.button == 2) {
|
||
if (amount > 0) {
|
||
item.system.treatment.value = Number(amount) - 1;
|
||
}
|
||
}
|
||
|
||
this.actor.updateEmbeddedDocuments('Item', [item]);
|
||
});
|
||
|
||
|
||
// Update Inventory Item
|
||
html.find('.item-equip').click(ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
//const item = duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId))
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
|
||
item.system.equipped = !item.system.equipped;
|
||
this.actor.updateEmbeddedDocuments('Item', [item]);
|
||
});
|
||
|
||
html.find('.sla-carry-toggle').click(async (ev) => {
|
||
ev.preventDefault();
|
||
const li = ev.currentTarget.closest(".item");
|
||
const targetState = String(ev.currentTarget.dataset.state ?? "carried");
|
||
const item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
const currentState = getCarryState(item);
|
||
const nextState = currentState === targetState ? "carried" : targetState;
|
||
item.system ??= {};
|
||
item.system.carryState = nextState;
|
||
if (item.type === "armor") item.system.equipped = nextState === "equipped";
|
||
await this.actor.updateEmbeddedDocuments('Item', [item]);
|
||
this.render(false);
|
||
});
|
||
|
||
// Add Inventory Item
|
||
html.find('.item-create').click(this._onItemCreate.bind(this));
|
||
|
||
// Update Inventory Item
|
||
html.find('.item-edit').click(ev => {
|
||
const li = $(ev.currentTarget).parents(".item");
|
||
const item = this.actor.getEmbeddedDocument("Item", li.data("itemId"));
|
||
item.sheet.render({force: true});
|
||
});
|
||
|
||
html.find('.drug-use').click(ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
this.actor.useSlaDrug(li.dataset.itemId);
|
||
});
|
||
|
||
html.find('.drug-close').click(ev => {
|
||
const itemButton = ev.currentTarget;
|
||
const li = itemButton.closest(".item");
|
||
const itemId = String(itemButton?.dataset?.itemId ?? li?.dataset?.itemId ?? "").trim();
|
||
const drugId = String(itemButton?.dataset?.drugId ?? li?.dataset?.drugId ?? "").trim();
|
||
if (!itemId && !drugId) {
|
||
ui.notifications.warn("No active drug could be identified to close.");
|
||
return;
|
||
}
|
||
this.actor.closeSlaDrug(itemId, drugId);
|
||
});
|
||
|
||
//Quantity adjuster
|
||
html.on('mousedown', '.item-quantity', ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
const sourceItem = this.actor.getEmbeddedDocument("Item", li.dataset.itemId);
|
||
if (!sourceItem) return;
|
||
const item = foundry.utils.duplicate(sourceItem);
|
||
const amount = Math.max(0, Number(item.system?.quantity ?? 0) || 0);
|
||
let delta = 0;
|
||
|
||
if (ev.button === 0) {
|
||
delta = 1;
|
||
} else if (ev.button === 2) {
|
||
delta = -1;
|
||
}
|
||
|
||
if (!delta) return;
|
||
item.system.quantity = Math.max(0, amount + delta);
|
||
|
||
this.actor.updateEmbeddedDocuments('Item', [item]).then(async () => {
|
||
if (delta > 0) {
|
||
await this._applySlaQuantityIncreaseDebit(sourceItem, delta);
|
||
}
|
||
});
|
||
});
|
||
|
||
//Severity adjuster
|
||
html.on('mousedown', '.severity', ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
|
||
|
||
let amount = item.system.severity;
|
||
|
||
if (event.button == 0) {
|
||
item.system.severity = Number(amount) + 1;
|
||
} else if (event.button == 2 && amount > 0) {
|
||
item.system.severity = Number(amount) - 1;
|
||
}
|
||
|
||
this.actor.updateEmbeddedDocuments('Item', [item]);
|
||
});
|
||
|
||
// Delete Inventory Item
|
||
html.find('.item-delete').click(ev => {
|
||
const li = $(ev.currentTarget).parents(".item");
|
||
this.actor.deleteEmbeddedDocuments("Item", [li.data("itemId")]);
|
||
li.slideUp(200, () => this.render(false));
|
||
});
|
||
|
||
//SKILLS
|
||
// Add Inventory Item
|
||
html.find('.skill-create').click(this._onSkillCreate.bind(this));
|
||
|
||
// Update Inventory Item
|
||
html.find('.skill-edit').click(ev => {
|
||
const li = $(ev.currentTarget).parents(".item");
|
||
const skill = this.actor.getEmbeddedDocument("Item", li.data("itemId"));
|
||
skill.sheet.render({force: true});
|
||
});
|
||
|
||
html.find('.ability-create').click(this._onItemCreate.bind(this));
|
||
|
||
html.find('.ability-edit').click(ev => {
|
||
const li = $(ev.currentTarget).parents(".item");
|
||
const ability = this.actor.getEmbeddedDocument("Item", li.data("itemId"));
|
||
ability.sheet.render({force: true});
|
||
});
|
||
|
||
html.find('.ability-use').click(ev => {
|
||
ev.preventDefault();
|
||
ev.stopPropagation();
|
||
const li = ev.currentTarget.closest(".item");
|
||
this.actor.useSlaAbility(li.dataset.itemId);
|
||
});
|
||
|
||
html.find('.ability-use-trigger').click(ev => {
|
||
ev.preventDefault();
|
||
ev.stopPropagation();
|
||
const li = ev.currentTarget.closest(".item");
|
||
this.actor.useSlaAbility(li.dataset.itemId);
|
||
});
|
||
|
||
//Weapons
|
||
// Add Inventory Item
|
||
html.find('.weapon-create').click(this._onItemCreate.bind(this));
|
||
|
||
// Update Inventory Item
|
||
html.find('.weapon-edit').click(ev => {
|
||
const li = $(ev.currentTarget).parents(".item");
|
||
const weapon = this.actor.getEmbeddedDocument("Item", li.data("itemId"));
|
||
weapon.sheet.render({force: true});
|
||
});
|
||
|
||
// Rollable Attribute
|
||
html.find('.stat-roll').click(ev => {
|
||
const div = $(ev.currentTarget);
|
||
const statName = div.data("key");
|
||
this.actor.rollCheck(null, 'low', statName, null, null, null);
|
||
});
|
||
|
||
// Rollable Skill
|
||
html.find('.skill-roll').click(ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
|
||
this.actor.rollCheck(null, null, null, item.name, item.system.bonus, null, null, { promptModifier: true });
|
||
});
|
||
|
||
html.find('.sla-ebb-skill-roll').click(ev => {
|
||
const itemId = ev.currentTarget.dataset.itemId;
|
||
if (!itemId) return;
|
||
this.actor.rollSlaEbbSkill(itemId);
|
||
});
|
||
|
||
html.find('.sla-rule-toggle input[type="checkbox"]').on('change', async ev => {
|
||
ev.stopPropagation();
|
||
const checkbox = ev.currentTarget;
|
||
await this.actor.update({ [checkbox.name]: checkbox.checked });
|
||
this.render(false);
|
||
});
|
||
|
||
html.find('.sla-rule-toggle').on('click', async ev => {
|
||
const checkbox = ev.currentTarget.querySelector('input[type="checkbox"]');
|
||
if (!checkbox || ev.target === checkbox) return;
|
||
ev.preventDefault();
|
||
const nextValue = !checkbox.checked;
|
||
checkbox.checked = nextValue;
|
||
await this.actor.update({ [checkbox.name]: nextValue });
|
||
this.render(false);
|
||
});
|
||
|
||
// Rollable Weapon
|
||
html.find('.weapon-roll').click(ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
//const item = duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
this.actor.rollWeaponAttack(item, { promptModifier: true });
|
||
});
|
||
|
||
// Rollable Damage
|
||
html.find('.dmg-roll').click(ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
//const item = duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
this.actor.rollCheck(null, null, 'damage', null, null, item);
|
||
});
|
||
|
||
// Rollable Item/Anything with a description that we want to click on.
|
||
html.find('.description-roll').click(ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
this.actor.printDescription(li.dataset.itemId, {
|
||
event: ev
|
||
});
|
||
});
|
||
|
||
html.on('mousedown', '.weapon-ammo', ev => {
|
||
ev.preventDefault();
|
||
if (ev.button !== 0) return;
|
||
const li = ev.currentTarget.closest(".item");
|
||
this.actor.promptWeaponReload(li.dataset.itemId);
|
||
});
|
||
|
||
html.on('mousedown', '.weapon-shots', ev => {
|
||
ev.preventDefault();
|
||
if (ev.button !== 0) return;
|
||
const li = ev.currentTarget.closest(".item");
|
||
this.actor.promptWeaponReload(li.dataset.itemId);
|
||
});
|
||
|
||
//Reload Shots
|
||
html.on('mousedown', '.weapon-reload', ev => {
|
||
ev.preventDefault();
|
||
if (ev.button !== 0) return;
|
||
const li = ev.currentTarget.closest(".item");
|
||
this.actor.promptWeaponReload(li.dataset.itemId);
|
||
});
|
||
|
||
html.on('mousedown', '.weapon-fire-mode', ev => {
|
||
ev.preventDefault();
|
||
const li = ev.currentTarget.closest(".item");
|
||
const direction = ev.button === 2 ? -1 : 1;
|
||
this.actor.cycleWeaponFireMode(li.dataset.itemId, direction);
|
||
});
|
||
html.on('contextmenu', '.weapon-fire-mode', ev => {
|
||
ev.preventDefault();
|
||
});
|
||
|
||
//increase AP
|
||
html.on('mousedown', '.armor-ap', ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
//const item = duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId))
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
let amount = item.system.armorPoints;
|
||
if (event.button == 0) {
|
||
item.system.armorPoints = Number(amount) + 1;
|
||
} else if (event.button == 2) {
|
||
if (amount > 0) {
|
||
item.system.armorPoints = Number(amount) - 1;
|
||
}
|
||
}
|
||
this.actor.updateEmbeddedDocuments('Item', [item]);
|
||
});
|
||
|
||
//increase DR
|
||
html.on('mousedown', '.armor-dr', ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
//const item = duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId))
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
let amount = item.system.damageReduction;
|
||
if (event.button == 0) {
|
||
item.system.damageReduction = Number(amount) + 1;
|
||
} else if (event.button == 2) {
|
||
if (amount > 0) {
|
||
item.system.damageReduction = Number(amount) - 1;
|
||
}
|
||
}
|
||
this.actor.updateEmbeddedDocuments('Item', [item]);
|
||
});
|
||
|
||
//increase oxygen
|
||
html.on('mousedown', '.armor-oxy', ev => {
|
||
const li = ev.currentTarget.closest(".item");
|
||
//const item = duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId))
|
||
var item;
|
||
item = foundry.utils.duplicate(this.actor.getEmbeddedDocument("Item", li.dataset.itemId));
|
||
let amount = item.system.oxygenCurrent;
|
||
if (event.button == 0) {
|
||
if (amount < item.system.oxygenMax) {
|
||
item.system.oxygenCurrent = Number(amount) + 1;
|
||
}
|
||
} else if (event.button == 2) {
|
||
if (amount > 0) {
|
||
item.system.oxygenCurrent = Number(amount) - 1;
|
||
}
|
||
}
|
||
this.actor.updateEmbeddedDocuments('Item', [item]);
|
||
});
|
||
|
||
// Calm - Panic Check
|
||
html.find('.calm-roll').click(ev => {
|
||
this.actor.rollCheck(null, 'low', 'fear', null, null, null);
|
||
});
|
||
|
||
// Stress - Panic Check
|
||
html.find('.stress-roll').click(ev => {
|
||
this.actor.rollCheck(null, 'low', 'fear', null, null, null);
|
||
});
|
||
|
||
html.find('.sla-flux-save').click(ev => {
|
||
this.actor.triggerSlaFluxPanic({ source: 'Flux control check', panicOnFailure: false });
|
||
});
|
||
|
||
html.find('.sla-flux-panic').click(ev => {
|
||
this.actor.triggerSlaFluxPanic({ source: 'Manual Flux panic check', panicOnFailure: true, forcePanic: true });
|
||
});
|
||
|
||
// Vevaphon morph form shift
|
||
html.find('.sla-morph-shift').click(async (ev) => {
|
||
const formName = ev.currentTarget.dataset.form;
|
||
if (!formName) return;
|
||
await this.actor.setSlaVevaphonMorphForm?.(formName);
|
||
this.render(false);
|
||
});
|
||
|
||
// Vevaphon instability +/-
|
||
html.find('.sla-instability-increase').click(async () => {
|
||
await this.actor.adjustSlaVevaphonInstability?.(1);
|
||
this.render(false);
|
||
});
|
||
html.find('.sla-instability-decrease').click(async () => {
|
||
await this.actor.adjustSlaVevaphonInstability?.(-1);
|
||
this.render(false);
|
||
});
|
||
|
||
// SCL fractional adjustment buttons
|
||
html.find('.sla-scl-adjust').click(async (ev) => {
|
||
ev.preventDefault();
|
||
const delta = parseFloat(ev.currentTarget.dataset.delta ?? 0);
|
||
if (!delta) return;
|
||
const current = parseFloat(String(this.actor.system?.sla?.scl?.value ?? "0").replace(",", ".")) || 0;
|
||
const next = Math.max(0, Math.round((current + delta) * 10) / 10);
|
||
const formatted = Number.isInteger(next) ? String(next) : next.toFixed(1);
|
||
await this.actor.update({ "system.sla.scl.value": formatted });
|
||
this.render(false);
|
||
});
|
||
|
||
// Session ability tracking — checkbox
|
||
html.find('.sla-session-ability-used').on('change', async (ev) => {
|
||
ev.stopPropagation();
|
||
await this.actor.update({ "system.sla.sessionAbilityUsed": ev.currentTarget.checked });
|
||
});
|
||
|
||
// New Session reset button
|
||
html.find('.sla-new-session').click(async (ev) => {
|
||
ev.preventDefault();
|
||
const confirmed = await Dialog.confirm({
|
||
title: "New Session",
|
||
content: "<p>Start a new session? This will reset the trauma response session ability for this operative.</p>",
|
||
defaultYes: true
|
||
});
|
||
if (!confirmed) return;
|
||
await this.actor.update({ "system.sla.sessionAbilityUsed": false });
|
||
ui.notifications.info(`${this.actor.name}: session ability reset for new session.`);
|
||
this.render(false);
|
||
});
|
||
|
||
// Rest button — short or long rest dialog
|
||
html.find('.sla-rest-button').click(async (ev) => {
|
||
ev.preventDefault();
|
||
const restType = await new Promise((resolve) => {
|
||
new Dialog({
|
||
title: "Take a Rest",
|
||
content: `
|
||
<p>What kind of rest is <strong>${this.actor.name}</strong> taking?</p>
|
||
<p><strong>Short Rest:</strong> Removes non-permanent conditions. No stat recovery.</p>
|
||
<p><strong>Long Rest:</strong> Removes non-permanent conditions and fully restores Flux (if Ebb user).</p>
|
||
`,
|
||
buttons: {
|
||
short: { icon: '<i class="fas fa-moon"></i>', label: "Short Rest", callback: () => resolve("short") },
|
||
long: { icon: '<i class="fas fa-bed"></i>', label: "Long Rest", callback: () => resolve("long") },
|
||
cancel: { icon: '<i class="fas fa-times"></i>', label: "Cancel", callback: () => resolve(null) }
|
||
},
|
||
default: "short"
|
||
}).render(true);
|
||
});
|
||
if (!restType) return;
|
||
|
||
const updates = {};
|
||
// Remove temporary conditions (items of type "condition")
|
||
const conditionIds = this.actor.items
|
||
.filter((item) => item.type === "condition")
|
||
.map((item) => item.id);
|
||
if (conditionIds.length > 0) {
|
||
await this.actor.deleteEmbeddedDocuments("Item", conditionIds);
|
||
}
|
||
|
||
if (restType === "long") {
|
||
// Restore Flux to max for Ebb users
|
||
const isEbb = this.actor.isSlaEbbUser?.() ?? false;
|
||
if (isEbb) {
|
||
const fluxMax = Math.max(0, Number(this.actor.system?.sla?.flux?.max ?? 0));
|
||
updates["system.sla.flux.value"] = fluxMax;
|
||
await this.actor.updateSlaFluxState?.(fluxMax, { save: true });
|
||
}
|
||
}
|
||
|
||
if (Object.keys(updates).length > 0) {
|
||
await this.actor.update(updates);
|
||
}
|
||
|
||
const condMsg = conditionIds.length > 0 ? ` Cleared ${conditionIds.length} condition(s).` : "";
|
||
const fluxMsg = restType === "long" && (this.actor.isSlaEbbUser?.() ?? false) ? " Flux restored." : "";
|
||
ui.notifications.info(`${this.actor.name}: ${restType === "long" ? "Long" : "Short"} rest complete.${condMsg}${fluxMsg}`);
|
||
await this.actor.addSlaActivityLog?.(`${restType === "long" ? "Long" : "Short"} rest.${condMsg}${fluxMsg}`);
|
||
this.render(false);
|
||
});
|
||
|
||
// Contact add button
|
||
html.find('.sla-contact-add').click(async (ev) => {
|
||
ev.preventDefault();
|
||
await this._slaContactDialog(null);
|
||
});
|
||
|
||
// Contact edit button
|
||
html.find('.sla-contact-edit').click(async (ev) => {
|
||
ev.preventDefault();
|
||
const contactId = String(ev.currentTarget.dataset.contactId ?? "").trim();
|
||
if (!contactId) return;
|
||
await this._slaContactDialog(contactId);
|
||
});
|
||
|
||
// Contact delete button
|
||
html.find('.sla-contact-delete').click(async (ev) => {
|
||
ev.preventDefault();
|
||
const contactId = String(ev.currentTarget.dataset.contactId ?? "").trim();
|
||
if (!contactId) return;
|
||
const confirmed = await Dialog.confirm({
|
||
title: "Delete Contact",
|
||
content: "<p>Remove this contact from the operative's network?</p>",
|
||
defaultYes: false
|
||
});
|
||
if (!confirmed) return;
|
||
const contacts = Array.isArray(this.actor.system?.sla?.contacts) ? [...this.actor.system.sla.contacts] : [];
|
||
const updated = contacts.filter((c) => c.id !== contactId);
|
||
await this.actor.update({ "system.sla.contacts": updated });
|
||
this.render(false);
|
||
});
|
||
|
||
html.find('.sla-panic-button').click(async ev => {
|
||
await this.actor.rollTable("panicCheck", null, null, null, null, null, null);
|
||
await this.actor.addSlaActivityLog?.("Panic check triggered.");
|
||
});
|
||
|
||
html.find('.sla-wound-button').click(ev => {
|
||
this.actor.chooseSlaWoundTable?.();
|
||
});
|
||
|
||
html.find('.trait-validate').click(() => {
|
||
const traitRows = buildSlaTraitRows(this.actor.items.filter((item) => item.type === "persTrait"));
|
||
const report = validateSlaTraitRows(traitRows);
|
||
const balance = Number(report?.rankBalance?.net ?? 0);
|
||
if (report.ok) {
|
||
ui.notifications.info(`Trait validation OK. Balance ${balance >= 0 ? "+" : ""}${balance}.`);
|
||
} else {
|
||
ui.notifications.warn(`Trait validation issues: ${report.errors.join(" ")}`);
|
||
}
|
||
this.render(false);
|
||
});
|
||
|
||
const captureTraitSelection = (ev) => {
|
||
ev.preventDefault();
|
||
ev.stopPropagation();
|
||
ev.stopImmediatePropagation();
|
||
const type = String(ev.currentTarget?.dataset?.type ?? "").trim().toLowerCase();
|
||
if (!type) return;
|
||
const value = String(ev.currentTarget?.value ?? "").trim();
|
||
this._slaTraitPickerSelection ??= {};
|
||
this._slaTraitPickerSelection[type] = value;
|
||
const pickerRow = ev.currentTarget.closest('.sla-trait-picker-row');
|
||
if (pickerRow?.dataset) {
|
||
pickerRow.dataset.selectedTrait = value;
|
||
}
|
||
const addButton = pickerRow?.querySelector?.(`.sla-trait-add[data-type="${type}"]`);
|
||
if (addButton?.dataset) {
|
||
addButton.dataset.selectedTrait = value;
|
||
}
|
||
};
|
||
|
||
html.find('.sla-trait-select').on('change input', captureTraitSelection);
|
||
|
||
html.find('.sla-trait-add').click(async (ev) => {
|
||
ev.preventDefault();
|
||
ev.stopPropagation();
|
||
ev.stopImmediatePropagation();
|
||
const type = String(ev.currentTarget.dataset.type ?? "").trim().toLowerCase();
|
||
const pickerRow = ev.currentTarget.closest('.sla-trait-picker-row');
|
||
const select = pickerRow?.querySelector(`.sla-trait-select[data-type="${type}"]`)
|
||
?? html.find(`.sla-trait-select[data-type="${type}"]`).get(0);
|
||
const selectedKey = String(
|
||
select?.value
|
||
?? pickerRow?.dataset?.selectedTrait
|
||
?? ev.currentTarget?.dataset?.selectedTrait
|
||
?? this._slaTraitPickerSelection?.[type]
|
||
?? ""
|
||
).trim();
|
||
if (!selectedKey) {
|
||
ui.notifications.warn(`Choose a ${type === "advantage" ? "positive" : "negative"} trait first.`);
|
||
return;
|
||
}
|
||
const options = type === "advantage" ? getSlaTraitOptionsByType("advantage") : getSlaTraitOptionsByType("disadvantage");
|
||
const selected = options.find((entry) => entry.key === selectedKey);
|
||
if (!selected) return;
|
||
const existing = this.actor.items.find((item) => item.type === "persTrait" && String(item.name ?? "").trim().toLowerCase() === selected.label.toLowerCase());
|
||
if (existing) {
|
||
ui.notifications.warn(`${selected.label} is already on this operative.`);
|
||
return;
|
||
}
|
||
await this.actor.createEmbeddedDocuments("Item", [{
|
||
name: selected.label,
|
||
type: "persTrait",
|
||
img: type === "advantage"
|
||
? "systems/sla-mothership/images/icons/ui/conditions/moral_compass.png"
|
||
: "systems/sla-mothership/images/icons/ui/conditions/anxiety.png",
|
||
system: {
|
||
base: 1,
|
||
xp: 0,
|
||
oppName: "",
|
||
basic: false,
|
||
improve: false,
|
||
oppimprove: false,
|
||
description: "",
|
||
gmDescription: "",
|
||
sla: {
|
||
traitType: type,
|
||
source: "SLA Trait Selector"
|
||
}
|
||
}
|
||
}]);
|
||
this._slaTraitPickerSelection ??= {};
|
||
this._slaTraitPickerSelection[type] = "";
|
||
if (pickerRow?.dataset) {
|
||
pickerRow.dataset.selectedTrait = "";
|
||
}
|
||
if (ev.currentTarget?.dataset) {
|
||
ev.currentTarget.dataset.selectedTrait = "";
|
||
}
|
||
if (select) select.value = "";
|
||
});
|
||
|
||
html.find('.sla-health-reset').click(async (ev) => {
|
||
ev.preventDefault();
|
||
const maxHealth = Math.max(0, Number(this.actor.system?.health?.max ?? 0) || 0);
|
||
await this.actor.update({ "system.health.value": maxHealth });
|
||
ui.notifications.info(`Health reset to ${maxHealth}.`);
|
||
this.render(false);
|
||
});
|
||
|
||
html.find('.weapon-reload-all').click(async (ev) => {
|
||
ev.preventDefault();
|
||
await this.actor.reloadAllCompatibleWeapons?.();
|
||
this.render(false);
|
||
});
|
||
|
||
// Clicking on Armor
|
||
html.find('.armor-roll').click(ev => {
|
||
//roll panic check
|
||
this.actor.chooseCover();
|
||
});
|
||
|
||
// Drag events for macros.
|
||
if (this.actor.isOwner) {
|
||
let handler = ev => this._onDragStart(ev);
|
||
|
||
html.find('li.dropitem').each((i, li) => {
|
||
if (li.classList.contains("inventory-header")) return;
|
||
li.setAttribute("draggable", true);
|
||
li.addEventListener("dragstart", handler, false);
|
||
});
|
||
}
|
||
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
|
||
async _onDrop(event) {
|
||
const data = TextEditor.getDragEventData(event);
|
||
if (data?.type !== "Item") return super._onDrop(event);
|
||
|
||
const droppedItem = await Item.implementation.fromDropData(data).catch(() => null);
|
||
if (!droppedItem) return super._onDrop(event);
|
||
|
||
if (droppedItem.parent?.uuid === this.actor.uuid) {
|
||
return super._onDrop(event);
|
||
}
|
||
|
||
const shouldDebitPurchase = !droppedItem.parent || droppedItem.parent.documentName !== "Actor";
|
||
const itemData = droppedItem.toObject();
|
||
delete itemData._id;
|
||
delete itemData.folder;
|
||
const created = await this.actor.createEmbeddedDocuments("Item", [itemData], {
|
||
slaPurchaseDebit: true,
|
||
slaPurchaseSource: data.uuid ?? droppedItem.uuid ?? ""
|
||
});
|
||
if (shouldDebitPurchase) {
|
||
await this._applySlaPurchaseDebit(created);
|
||
}
|
||
return created;
|
||
}
|
||
|
||
async _applySlaPurchaseDebit(createdDocs = []) {
|
||
const documents = Array.isArray(createdDocs) ? createdDocs : [createdDocs];
|
||
const total = Math.round(documents.reduce((sum, doc) => sum + getPurchasableItemTotalCost(doc?.toObject?.() ?? doc), 0) * 100) / 100;
|
||
if (!total) return;
|
||
|
||
const currentCredits = Number(this.actor.system?.credits?.value ?? 0) || 0;
|
||
const newCredits = Math.round((currentCredits - total) * 100) / 100;
|
||
const updateData = { "system.credits.value": newCredits };
|
||
|
||
const itemNames = documents.map((doc) => doc?.name).filter(Boolean).join(", ");
|
||
const ammoDocs = documents
|
||
.map((doc) => doc?.toObject?.() ?? doc)
|
||
.filter((doc) => isAmmoPurchaseItem(doc));
|
||
if (ammoDocs.length) {
|
||
const stamp = formatSlaTimestamp();
|
||
const currentLedger = String(this.actor.system?.sla?.ammoLedger?.value ?? "").trim();
|
||
const purchaseEntries = ammoDocs.map((doc) => {
|
||
const system = doc?.system ?? doc?.data ?? {};
|
||
const quantity = Math.max(1, Number(system.quantity ?? 1) || 1);
|
||
const unitCost = Number(system.cost ?? 0) || 0;
|
||
const lineCost = Math.round(unitCost * quantity * 100) / 100;
|
||
return `[${stamp}] PURCHASE | ${doc?.name ?? "Ammo"} | ${quantity} round${quantity === 1 ? "" : "s"} | -${lineCost} cR | balance ${newCredits} cR`;
|
||
});
|
||
const ledgerLines = [...purchaseEntries, ...currentLedger.split("\n").filter(Boolean)].slice(0, 60);
|
||
updateData["system.sla.ammoLedger.value"] = ledgerLines.join("\n");
|
||
}
|
||
|
||
await this.actor.update(updateData);
|
||
|
||
ui.notifications.info(`${this.actor.name}: deducted ${total} cR for ${itemNames || "purchased item"}. Credits now ${newCredits} cR.`);
|
||
await this.actor.addSlaActivityLog?.(`Purchased ${itemNames || "item"} for ${total} cR. Credits now ${newCredits} cR.`);
|
||
}
|
||
|
||
async _applySlaQuantityIncreaseDebit(itemDoc, increase = 0) {
|
||
const added = Math.max(0, Number(increase ?? 0) || 0);
|
||
if (!added || !itemDoc) return;
|
||
|
||
const unitCost = Number(itemDoc.system?.cost ?? 0) || 0;
|
||
const total = Math.round(unitCost * added * 100) / 100;
|
||
if (!total) return;
|
||
|
||
const currentCredits = Number(this.actor.system?.credits?.value ?? 0) || 0;
|
||
const newCredits = Math.round((currentCredits - total) * 100) / 100;
|
||
const updateData = { "system.credits.value": newCredits };
|
||
|
||
if (isAmmoPurchaseItem(itemDoc)) {
|
||
const stamp = formatSlaTimestamp();
|
||
const currentLedger = String(this.actor.system?.sla?.ammoLedger?.value ?? "").trim();
|
||
const entry = `[${stamp}] PURCHASE | ${itemDoc.name ?? "Ammo"} | ${added} round${added === 1 ? "" : "s"} | -${total} cR | balance ${newCredits} cR`;
|
||
const ledgerLines = [entry, ...currentLedger.split("\n").filter(Boolean)].slice(0, 60);
|
||
updateData["system.sla.ammoLedger.value"] = ledgerLines.join("\n");
|
||
}
|
||
|
||
await this.actor.update(updateData);
|
||
ui.notifications.info(`${this.actor.name}: deducted ${total} cR for ${added} more ${itemDoc.name ?? "item"}. Credits now ${newCredits} cR.`);
|
||
await this.actor.addSlaActivityLog?.(`Purchased +${added} ${itemDoc.name ?? "item"} for ${total} cR. Credits now ${newCredits} cR.`);
|
||
}
|
||
|
||
/* -------------------------------------------- */
|
||
|
||
/**
|
||
* 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
|
||
*/
|
||
_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.
|
||
var data;
|
||
data = foundry.utils.duplicate(header.dataset);
|
||
|
||
// Initialize a default name.
|
||
const name = type === "persTrait" ? "New Trait" : `New ${type.capitalize()}`;
|
||
// Prepare the item object.
|
||
const itemData = {
|
||
name: name,
|
||
type: type,
|
||
data: data
|
||
};
|
||
|
||
// Remove the type from the dataset since it's in the itemData.type prop.
|
||
delete itemData.data["type"];
|
||
|
||
// Finally, create the item!
|
||
return this.actor.createEmbeddedDocuments("Item", [itemData]);
|
||
}
|
||
|
||
/**
|
||
* Handle creating a new Owned skill for the actor using initial data defined in the HTML dataset
|
||
* @param {Event} event The originating click event
|
||
* @private
|
||
*/
|
||
_onSkillCreate(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.
|
||
var data;
|
||
data = foundry.utils.duplicate(header.dataset);
|
||
//const data = duplicate(header.dataset);
|
||
// Initialize a default name.
|
||
const name = `New Skill`;
|
||
// Prepare the item object.
|
||
const itemData = {
|
||
name: name,
|
||
type: type,
|
||
system: data
|
||
};
|
||
|
||
let d = new foundry.applications.api.DialogV2({
|
||
window: {title: `New Skill`},
|
||
classes: ["macro-popup-dialog"],
|
||
content: `
|
||
<div class="macro_window">
|
||
<div class="macro_desc" style="padding-left: 8px; padding-bottom: 0px;">
|
||
<h4> Name </h4>
|
||
</div>
|
||
<input type="text" id="name" name="name" value="New Skill">
|
||
</div>
|
||
<div class="macro_window">
|
||
<div class="macro_desc" style="padding-left: 8px; padding-bottom: 0px;">
|
||
<h4> Rank </h4>
|
||
</div>
|
||
<select name="rank" id="rank">
|
||
<option value="Trained">Trained</option>
|
||
<option value="Expert">Expert</option>
|
||
<option value="Master">Master</option>
|
||
</select>
|
||
</div>
|
||
`,
|
||
buttons: [
|
||
{
|
||
icon: 'fas fa-check',
|
||
action: "create",
|
||
label: "Create",
|
||
callback: (event, button, dialog) => {
|
||
var rank = button.form.querySelector('[id=\"rank\"]')?.value;
|
||
if (rank == "Trained")
|
||
itemData.system.bonus = 10;
|
||
if (rank == "Expert")
|
||
itemData.system.bonus = 15;
|
||
if (rank == "Master")
|
||
itemData.system.bonus = 20;
|
||
|
||
itemData.system.rank = rank;
|
||
itemData.name = button.form.querySelector('[id=\"name\"]')?.value
|
||
this.actor.createEmbeddedDocuments("Item", [itemData]);
|
||
}
|
||
},
|
||
{
|
||
icon: 'fas fa-times',
|
||
action: "cancel",
|
||
label: "Cancel",
|
||
callback: () => { }
|
||
}
|
||
],
|
||
default: "roll",
|
||
close: () => { }
|
||
});
|
||
d.render({force: true});
|
||
|
||
// Finally, create the item!
|
||
return;
|
||
}
|
||
|
||
|
||
/**
|
||
* Handle clickable rolls.
|
||
* @param {Event} event The originating click event
|
||
* @private
|
||
*/
|
||
_onRoll(event) {
|
||
event.preventDefault();
|
||
const element = event.currentTarget;
|
||
const dataset = element.dataset;
|
||
|
||
if (dataset.roll) {
|
||
let roll = new Roll(dataset.roll, this.actor.system);
|
||
let label = dataset.label ? `Rolling ${dataset.label} to score under ${dataset.target}` : '';
|
||
roll.roll().toMessage({
|
||
speaker: ChatMessage.getSpeaker({ actor: this.actor }),
|
||
flavor: label
|
||
});
|
||
}
|
||
}
|
||
|
||
async _updateObject(event, formData) {
|
||
const actor = this.object;
|
||
|
||
var updateData;
|
||
updateData = foundry.utils.expandObject(formData);
|
||
|
||
await actor.update(updateData, {
|
||
diff: false
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Show a dialog for adding or editing a contact
|
||
* @param {string|null} contactId null = add new, string = edit existing
|
||
*/
|
||
async _slaContactDialog(contactId) {
|
||
const contacts = Array.isArray(this.actor.system?.sla?.contacts) ? [...this.actor.system.sla.contacts] : [];
|
||
const existing = contactId ? contacts.find((c) => c.id === contactId) : null;
|
||
const isNew = !existing;
|
||
|
||
const name = existing?.name ?? "";
|
||
const role = existing?.role ?? "";
|
||
const notes = existing?.notes ?? "";
|
||
const disposition = existing?.disposition ?? "neutral";
|
||
|
||
const content = `
|
||
<div style="display:grid; gap:8px; padding:8px 0;">
|
||
<div>
|
||
<label style="font-size:0.8rem; font-weight:600; display:block; margin-bottom:4px;">Name</label>
|
||
<input type="text" id="sla-contact-name" value="${name}" placeholder="Contact name" style="width:100%;" />
|
||
</div>
|
||
<div>
|
||
<label style="font-size:0.8rem; font-weight:600; display:block; margin-bottom:4px;">Role / Occupation</label>
|
||
<input type="text" id="sla-contact-role" value="${role}" placeholder="e.g. Fixer, Fence, Squad medic" style="width:100%;" />
|
||
</div>
|
||
<div>
|
||
<label style="font-size:0.8rem; font-weight:600; display:block; margin-bottom:4px;">Disposition</label>
|
||
<select id="sla-contact-disposition" style="width:100%;">
|
||
<option value="ally" ${disposition === "ally" ? "selected" : ""}>Ally</option>
|
||
<option value="neutral" ${disposition === "neutral" ? "selected" : ""}>Neutral</option>
|
||
<option value="hostile" ${disposition === "hostile" ? "selected" : ""}>Hostile</option>
|
||
<option value="unknown" ${disposition === "unknown" ? "selected" : ""}>Unknown</option>
|
||
</select>
|
||
</div>
|
||
<div>
|
||
<label style="font-size:0.8rem; font-weight:600; display:block; margin-bottom:4px;">Notes</label>
|
||
<textarea id="sla-contact-notes" rows="3" placeholder="Sector, history, how they know the operative..." style="width:100%;">${notes}</textarea>
|
||
</div>
|
||
</div>
|
||
`;
|
||
|
||
const result = await Dialog.prompt({
|
||
title: isNew ? "Add Contact" : "Edit Contact",
|
||
content,
|
||
label: isNew ? "Add" : "Save",
|
||
callback: (html) => {
|
||
const nameVal = String(html.find("#sla-contact-name").val() ?? "").trim();
|
||
if (!nameVal) return null;
|
||
return {
|
||
id: existing?.id ?? foundry.utils.randomID(),
|
||
name: nameVal,
|
||
role: String(html.find("#sla-contact-role").val() ?? "").trim(),
|
||
disposition: String(html.find("#sla-contact-disposition").val() ?? "neutral"),
|
||
notes: String(html.find("#sla-contact-notes").val() ?? "").trim()
|
||
};
|
||
},
|
||
rejectClose: false
|
||
});
|
||
|
||
if (!result) return;
|
||
|
||
let updated;
|
||
if (isNew) {
|
||
updated = [...contacts, result];
|
||
} else {
|
||
updated = contacts.map((c) => c.id === contactId ? result : c);
|
||
}
|
||
await this.actor.update({ "system.sla.contacts": updated });
|
||
this.render(false);
|
||
}
|
||
|
||
/**
|
||
* Extend and override the sheet header buttons
|
||
* @override
|
||
*/
|
||
_getHeaderButtons() {
|
||
let buttons = super._getHeaderButtons();
|
||
const canConfigure = game.user.isGM || this.actor.isOwner;
|
||
if (this.options.editable && canConfigure) {
|
||
buttons = [{
|
||
label: "Theme",
|
||
class: 'sheet-theme-toggle',
|
||
icon: 'fas fa-palette',
|
||
onclick: (ev) => this._onToggleTheme(ev),
|
||
}, {
|
||
label: "Generator",
|
||
class: 'configure-actor',
|
||
icon: 'fas fa-cogs',
|
||
onclick: (ev) => this._onConfigureCreature(ev),
|
||
},].concat(buttons);
|
||
}
|
||
return buttons;
|
||
}
|
||
async _onToggleTheme(event) {
|
||
event.preventDefault();
|
||
const currentTheme = (await this.actor.getFlag("sla-mothership", "sheetTheme")) || "modern";
|
||
const nextTheme = currentTheme === "legacy" ? "modern" : "legacy";
|
||
await this.actor.setFlag("sla-mothership", "sheetTheme", nextTheme);
|
||
this._setThemeClassState(nextTheme);
|
||
ui.notifications.info(`Character sheet theme: ${nextTheme === "legacy" ? "Legacy" : "Modern SLA"}`);
|
||
await this.render(true);
|
||
this._setThemeClassState(nextTheme);
|
||
}
|
||
_setThemeClassState(theme) {
|
||
const root = this.element?.[0] ?? null;
|
||
if (!root) return;
|
||
root.dataset.slaTheme = theme;
|
||
root.classList.remove("sla-sheet-theme-legacy", "sla-sheet-theme-modern");
|
||
root.classList.add(`sla-sheet-theme-${theme}`);
|
||
if (this.element?.removeClass) {
|
||
this.element.removeClass("sla-sheet-theme-legacy sla-sheet-theme-modern");
|
||
this.element.addClass(`sla-sheet-theme-${theme}`);
|
||
}
|
||
const windowApp = root.closest(".window-app");
|
||
const windowContent = root.closest(".window-content");
|
||
const windowHeader = windowApp?.querySelector?.(".window-header") ?? null;
|
||
if (windowApp) {
|
||
windowApp.dataset.slaTheme = theme;
|
||
windowApp.classList.remove("sla-window-theme-legacy", "sla-window-theme-modern");
|
||
windowApp.classList.add(`sla-window-theme-${theme}`);
|
||
}
|
||
if (windowContent) {
|
||
windowContent.dataset.slaTheme = theme;
|
||
windowContent.classList.remove("sla-window-theme-legacy", "sla-window-theme-modern");
|
||
windowContent.classList.add(`sla-window-theme-${theme}`);
|
||
}
|
||
if (windowHeader) {
|
||
windowHeader.dataset.slaTheme = theme;
|
||
windowHeader.classList.remove("sla-window-theme-legacy", "sla-window-theme-modern");
|
||
windowHeader.classList.add(`sla-window-theme-${theme}`);
|
||
}
|
||
}
|
||
_applyThemeClasses(html) {
|
||
const root = html?.get?.(0) ?? html?.[0] ?? null;
|
||
if (!root) return;
|
||
const theme = this.actor.getFlag("sla-mothership", "sheetTheme") || "modern";
|
||
root.classList.remove("sla-sheet-theme-legacy", "sla-sheet-theme-modern");
|
||
root.classList.add(`sla-sheet-theme-${theme}`);
|
||
this._setThemeClassState(theme);
|
||
}
|
||
_onConfigureCreature(event) {
|
||
event.preventDefault();
|
||
new SLAMothershipGenerator(this.actor, {
|
||
top: this.position.top + 40,
|
||
left: this.position.left + (this.position.width - 400) / 2
|
||
}).render({force: true});
|
||
}
|
||
}
|
||
|
||
export class MothershipActorSheetDossier extends MothershipActorSheet {
|
||
static get defaultOptions() {
|
||
const base = super.defaultOptions;
|
||
const classes = Array.from(new Set([...(base.classes ?? []), "sla-dossier-sheet"]));
|
||
return foundry.utils.mergeObject(base, {
|
||
classes,
|
||
width: 980,
|
||
height: 920
|
||
});
|
||
}
|
||
}
|
||
|
||
function parseWeaponFireModes(raw) {
|
||
const modes = [];
|
||
for (const chunk of String(raw ?? "").split(/[\n,]+/)) {
|
||
const entry = chunk.trim();
|
||
if (!entry) continue;
|
||
const match = entry.match(/^(.+?)(?:\s*[:=|-]\s*|\s*\(\s*)(\d+)\)?$/);
|
||
if (!match) continue;
|
||
modes.push({
|
||
label: match[1].trim(),
|
||
shots: Math.max(1, Number(match[2]) || 1)
|
||
});
|
||
}
|
||
return modes;
|
||
}
|
||
|
||
function deriveWeaponFireModes(system) {
|
||
const shotsPerFire = Math.max(1, Number(system?.shotsPerFire ?? 1) || 1);
|
||
const special = String(system?.sla?.special ?? "").toLowerCase();
|
||
const modes = [{ label: "Single", shots: 1 }];
|
||
|
||
if (shotsPerFire > 1) {
|
||
if (special.includes("auto") && shotsPerFire > 3) {
|
||
modes.push({ label: "Burst", shots: 3 }, { label: "Auto", shots: shotsPerFire });
|
||
} else if (special.includes("auto")) {
|
||
modes.push({ label: "Auto", shots: shotsPerFire });
|
||
} else if (special.includes("burst")) {
|
||
modes.push({ label: "Burst", shots: shotsPerFire });
|
||
} else if (shotsPerFire === 2) {
|
||
modes.push({ label: "Double", shots: 2 });
|
||
} else {
|
||
modes.push({ label: "Burst", shots: shotsPerFire });
|
||
}
|
||
}
|
||
|
||
return modes
|
||
.filter((mode, index, list) => list.findIndex((entry) => entry.label === mode.label && entry.shots === mode.shots) === index)
|
||
.map((mode) => `${mode.label}:${mode.shots}`)
|
||
.join(", ");
|
||
}
|
||
|
||
function getActiveFireMode(system) {
|
||
const modes = parseWeaponFireModes(system?.sla?.fireModes);
|
||
const currentMode = String(system?.sla?.currentFireMode ?? "").trim().toLowerCase();
|
||
return modes.find((mode) => mode.label.toLowerCase() === currentMode) ?? modes[0] ?? { label: "Single", shots: 1 };
|
||
}
|
||
|
||
function getAmmoReserveKey(tag = "STD") {
|
||
const normalized = String(tag ?? "STD").trim().toUpperCase();
|
||
if (normalized === "AP") return "ammoReserveAp";
|
||
if (normalized === "HE") return "ammoReserveHe";
|
||
if (normalized === "HEAP") return "ammoReserveHeap";
|
||
return "ammoReserveStd";
|
||
}
|
||
|
||
function getAmmoReserveTotal(system = {}) {
|
||
return ["ammoReserveStd", "ammoReserveAp", "ammoReserveHe", "ammoReserveHeap"]
|
||
.reduce((total, key) => total + Math.max(0, Number(system?.[key] ?? 0) || 0), 0);
|
||
}
|
||
|
||
function summarizeWeaponAmmoInventory(actor, weapon = {}) {
|
||
const calibre = String(weapon?.ammoCalibre ?? weapon?.ammoType ?? "").trim();
|
||
const allowedTags = new Set(
|
||
[
|
||
weapon?.ammoAllowStd !== false ? "STD" : null,
|
||
weapon?.ammoAllowAp !== false ? "AP" : null,
|
||
weapon?.ammoAllowHe !== false ? "HE" : null,
|
||
weapon?.ammoAllowHeap !== false ? "HEAP" : null
|
||
].filter(Boolean)
|
||
);
|
||
|
||
const matchingItems = Array.from(actor?.items ?? []).filter((item) => {
|
||
if (item.type !== "item") return false;
|
||
if (String(item.system?.sla?.category ?? "").trim().toLowerCase() !== "ammunition") return false;
|
||
const itemCalibre = String(item.system?.sla?.calibre ?? "").trim();
|
||
if (calibre && itemCalibre && itemCalibre !== calibre) return false;
|
||
const tag = String(item.system?.sla?.ammoTag ?? "STD").trim().toUpperCase();
|
||
return allowedTags.has(tag);
|
||
});
|
||
|
||
if (!matchingItems.length) {
|
||
return {
|
||
total: getAmmoReserveTotal(weapon),
|
||
byTag: {
|
||
STD: Math.max(0, Number(weapon?.ammoReserveStd ?? weapon?.ammo ?? 0) || 0),
|
||
AP: Math.max(0, Number(weapon?.ammoReserveAp ?? 0) || 0),
|
||
HE: Math.max(0, Number(weapon?.ammoReserveHe ?? 0) || 0),
|
||
HEAP: Math.max(0, Number(weapon?.ammoReserveHeap ?? 0) || 0)
|
||
},
|
||
choices: []
|
||
};
|
||
}
|
||
|
||
const byTag = { STD: 0, AP: 0, HE: 0, HEAP: 0 };
|
||
for (const item of matchingItems) {
|
||
const tag = String(item.system?.sla?.ammoTag ?? "STD").trim().toUpperCase();
|
||
byTag[tag] = (byTag[tag] ?? 0) + Math.max(0, Number(item.system?.quantity ?? 0) || 0);
|
||
}
|
||
|
||
return {
|
||
total: Object.values(byTag).reduce((sum, value) => sum + value, 0),
|
||
byTag,
|
||
choices: matchingItems
|
||
};
|
||
}
|
||
|
||
function getSpeciesRules(speciesName, store = {}) {
|
||
const rules = SLA_SPECIES_RULES[speciesName] ?? [];
|
||
return rules.map((rule) => {
|
||
store[rule.key] ??= {
|
||
enabled: rule.default,
|
||
label: rule.label,
|
||
summary: rule.summary,
|
||
optional: rule.optional
|
||
};
|
||
return {
|
||
key: rule.key,
|
||
label: rule.label,
|
||
summary: rule.summary,
|
||
optional: rule.optional,
|
||
enabled: Boolean(store[rule.key]?.enabled),
|
||
path: `system.sla.speciesRules.${rule.key}.enabled`
|
||
};
|
||
});
|
||
}
|