uberwald/foundryvtt-mgt2
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e18dd8abfaa27a0fa1bdbfc50b74cd67a075efb3
foundryvtt-mgt2/mgt2.bundle.js

2413 lines
95 KiB
JavaScript
Raw Blame History

const fields = foundry.data.fields;
class CharacterData extends foundry.abstract.TypeDataModel {
static defineSchema() {
return {
name: new fields.StringField({ required: false, blank: false, trim: true }),
life: new fields.SchemaField({
value: new fields.NumberField({ required: false, initial: 0, integer: true }),
max: new fields.NumberField({ required: true, initial: 0, integer: true })
}),
personal: new fields.SchemaField({
title: new fields.StringField({ required: false, blank: true, trim: true }),
species: new fields.StringField({ required: false, blank: true, trim: true }),
age: new fields.StringField({ required: false, blank: true, trim: true }),
gender: new fields.StringField({ required: false, blank: true, trim: true }),
pronouns: new fields.StringField({ required: false, blank: true, trim: true }),
homeworld: new fields.StringField({ required: false, blank: true, trim: true }),
ucp: new fields.StringField({ required: false, blank: true, trim: true, initial: "" })
}),
biography: new fields.HTMLField({ required: false, blank: true, trim: true }),
characteristics: new fields.SchemaField({
strength: createCharacteristicField(true, true),
dexterity: createCharacteristicField(true, true),
endurance: createCharacteristicField(true, true),
intellect: createCharacteristicField(true, false),
education: createCharacteristicField(true, false),
social: createCharacteristicField(true, false),
morale: createCharacteristicField(true, false),
luck: createCharacteristicField(true, false),
sanity: createCharacteristicField(true, false),
charm: createCharacteristicField(true, false),
psionic: createCharacteristicField(true, false),
other: createCharacteristicField(true, false)
}),
health: new fields.SchemaField({
radiations: new fields.NumberField({ required: false, initial: 0, min: 0, integer: true })
}),
study: new fields.SchemaField({
skill: new fields.StringField({ required: false, blank: true, trim: true, initial: "" }),
total: new fields.NumberField({ required: false, initial: 0, min: 0, integer: true }),
completed: new fields.NumberField({ required: false, initial: 0, min: 0, integer: true })
}),
finance: new fields.SchemaField({
pension: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true }),
credits: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true }),
cashOnHand: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true }),
debt: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true }),
livingCost: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true }),
monthlyShipPayments: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true }),
notes: new fields.StringField({ required: false, blank: true, trim: true, initial: "" })
}),
containerView: new fields.StringField({ required: false, blank: true, trim: true, initial: "" }),
containerDropIn: new fields.StringField({ required: false, blank: true, trim: true, initial: "" }),
notes: new fields.HTMLField({ required: false, blank: true, trim: true }),
inventory: new fields.SchemaField({
armor: new fields.NumberField({ required: true, initial: 0, integer: true }),
weight: new fields.NumberField({ required: true, initial: 0, min: 0, integer: false }),
encumbrance: new fields.SchemaField({
normal: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true }),
heavy: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true })
})
}),
states: new fields.SchemaField({
encumbrance: new fields.BooleanField({ required: false, initial: false }),
fatigue: new fields.BooleanField({ required: false, initial: false }),
unconscious: new fields.BooleanField({ required: false, initial: false }),
surgeryRequired: new fields.BooleanField({ required: false, initial: false })
}),
config: new fields.SchemaField({
psionic: new fields.BooleanField({ required: false, initial: true }),
initiative: new fields.StringField({ required: false, blank: true, initial: "dexterity" }),
damages: new fields.SchemaField({
rank1: new fields.StringField({ required: false, blank: true, initial: "strength" }),
rank2: new fields.StringField({ required: false, blank: true, initial: "dexterity" }),
rank3: new fields.StringField({ required: false, blank: true, initial: "endurance" })
})
})
};
}
}
class VehiculeData extends foundry.abstract.TypeDataModel {
static defineSchema() {
return {
name: new fields.StringField({ required: false, blank: false, trim: true }),
skillId: new fields.StringField({ required: false, initial: "", blank: true, trim: true }),
speed: new fields.SchemaField({
cruise: new fields.StringField({ required: false, initial: "Slow", blank: true }),
maximum: new fields.StringField({ required: false, initial: "Medium", blank: true })
}),
agility: new fields.NumberField({ required: false, min: 0, integer: true }),
crew: new fields.NumberField({ required: false, min: 0, integer: true }),
passengers: new fields.NumberField({ required: false, min: 0, integer: true }),
cargo: new fields.NumberField({ required: false, min: 0, integer: false }),
//hull
life: new fields.SchemaField({
value: new fields.NumberField({ required: true, initial: 0, integer: true }),
max: new fields.NumberField({ required: true, initial: 0, integer: true })
}),
shipping: new fields.NumberField({ required: false, min: 0, integer: true }),
cost: new fields.NumberField({ required: false, min: 0, integer: true }),
armor: new fields.SchemaField({
front: new fields.NumberField({ required: true, initial: 0, integer: true }),
rear: new fields.NumberField({ required: true, initial: 0, integer: true }),
sides: new fields.NumberField({ required: true, initial: 0, integer: true })
}),
skills: new fields.SchemaField({
// Skill Level
autopilot: new fields.NumberField({ required: true, initial: 0, integer: true })
// Communication Range
// Navigation
// Sensors
// Camouflage / Recon
// Stealth
})
// config: new fields.SchemaField({
// })
};
}
}
class ItemBaseData extends foundry.abstract.TypeDataModel {
static defineSchema() {
const fields2 = foundry.data.fields;
const schema = {
//name: new fields.StringField({ required: true, blank: true, trim: true, nullable: true }),
description: new fields2.StringField({ required: false, blank: true, trim: true, nullable: true }),
//type: new fields.StringField({ required: false, blank: false }),
subType: new fields2.StringField({ required: false, blank: false, nullable: true })
};
return schema;
}
}
class PhysicalItemData extends ItemBaseData {
static defineSchema() {
const schema = super.defineSchema();
schema.quantity = new fields.NumberField({ required: true, initial: 1, min: 0, integer: true });
schema.weight = new fields.NumberField({ required: true, initial: 0, min: 0, integer: false });
schema.weightless = new fields.BooleanField({ required: false, initial: false });
schema.cost = new fields.NumberField({ required: true, initial: 0, min: 0, integer: true });
schema.tl = new fields.StringField({ required: true, blank: false, initial: "TL12" });
schema.container = new fields.SchemaField({
//inContainer: new fields.BooleanField({ required: false, initial: false }),
id: new fields.StringField({ required: false, blank: true })
});
schema.roll = new fields.SchemaField({
characteristic: new fields.StringField({ required: false, blank: true, trim: true }),
skill: new fields.StringField({ required: false, blank: true, trim: true }),
difficulty: new fields.StringField({ required: false, blank: true, trim: true })
});
schema.trash = new fields.BooleanField({ required: false, initial: false });
return schema;
}
}
class ItemData extends PhysicalItemData {
static defineSchema() {
const schema = super.defineSchema();
schema.subType.initial = "loot";
schema.software = new fields.SchemaField({
bandwidth: new fields.NumberField({ required: false, initial: 0, min: 0, max: 10, integer: true }),
effect: new fields.StringField({ required: false, blank: true, trim: true, initial: "" }),
computerId: new fields.StringField({ required: false, blank: true, initial: "" })
});
return schema;
}
}
class EquipmentData extends PhysicalItemData {
static defineSchema() {
const schema = super.defineSchema();
schema.equipped = new fields.BooleanField({ required: false, initial: false });
schema.augment = new fields.SchemaField({
improvement: new fields.StringField({ required: false, blank: true, trim: true })
});
schema.subType.initial = "equipment";
return schema;
}
}
class DiseaseData extends ItemBaseData {
static defineSchema() {
const schema = super.defineSchema();
schema.subType.initial = "disease";
schema.difficulty = new fields.StringField({ required: true, initial: "Average" });
schema.damage = new fields.StringField({ required: false, blank: true });
schema.interval = new fields.StringField({ required: false, blank: true });
return schema;
}
}
class CareerData extends ItemBaseData {
static defineSchema() {
const schema = super.defineSchema();
schema.difficulty = new fields.NumberField({ required: true, initial: 0, min: 0, integer: true });
schema.damage = new fields.StringField({ required: false, blank: true });
schema.interval = new fields.StringField({ required: false, blank: true });
schema.assignment = new fields.StringField({ required: false, blank: true });
schema.terms = new fields.NumberField({ required: false, initial: 0, min: 0, integer: true });
schema.rank = new fields.NumberField({ required: false, initial: 0, min: 0, integer: true });
schema.events = new fields.ArrayField(
new fields.SchemaField({
age: new fields.NumberField({ required: false, integer: true }),
description: new fields.StringField({ required: false, blank: true, trim: true })
})
);
return schema;
}
}
class TalentData extends ItemBaseData {
static defineSchema() {
const schema = super.defineSchema();
schema.subType.initial = "skill";
schema.cost = new fields.NumberField({ required: true, initial: 0, min: 0, integer: true });
schema.level = new fields.NumberField({ required: true, initial: 0, min: 0, integer: true });
schema.skill = new fields.SchemaField({
speciality: new fields.StringField({ required: false, blank: true, trim: true }),
reduceEncumbrance: new fields.BooleanField({ required: false, initial: false })
});
schema.psionic = new fields.SchemaField({
reach: new fields.StringField({ required: false, blank: true, trim: true }),
cost: new fields.NumberField({ required: false, initial: 1, min: 0, integer: true })
});
schema.roll = new fields.SchemaField({
characteristic: new fields.StringField({ required: false, blank: true, trim: true }),
skill: new fields.StringField({ required: false, blank: true, trim: true }),
difficulty: new fields.StringField({ required: false, blank: true, trim: true })
});
return schema;
}
}
class ContactData extends ItemBaseData {
static defineSchema() {
const schema = super.defineSchema();
schema.subType.initial = "skill";
schema.cost = new fields.NumberField({ required: true, initial: 1, min: 0, integer: true });
schema.skill = new fields.SchemaField({
speciality: new fields.StringField({ required: false, blank: true, trim: true }),
characteristic: new fields.StringField({ required: false, blank: true, trim: true })
});
schema.status = new fields.StringField({ required: false, blank: true, trim: true, initial: "Alive" });
schema.attitude = new fields.StringField({ required: false, blank: true, trim: true, initial: "Unknow" });
schema.relation = new fields.StringField({ required: false, blank: true, trim: true, initial: "Contact" });
schema.title = new fields.StringField({ required: false, blank: true, trim: true });
schema.nickname = new fields.StringField({ required: false, blank: true, trim: true });
schema.species = new fields.StringField({ required: false, blank: true, trim: true });
schema.gender = new fields.StringField({ required: false, blank: true, trim: true });
schema.pronouns = new fields.StringField({ required: false, blank: true, trim: true });
schema.homeworld = new fields.StringField({ required: false, blank: true, trim: true });
schema.location = new fields.StringField({ required: false, blank: true, trim: true });
schema.occupation = new fields.StringField({ required: false, blank: true, trim: true });
schema.notes = new fields.HTMLField({ required: false, blank: true, trim: true });
return schema;
}
}
class WeaponData extends PhysicalItemData {
static defineSchema() {
const schema = super.defineSchema();
schema.equipped = new fields.BooleanField({ required: false, initial: false });
schema.range = new fields.SchemaField({
isMelee: new fields.BooleanField({ required: false, initial: false }),
value: new fields.NumberField({ required: false, integer: true, nullable: true }),
unit: new fields.StringField({ required: false, blank: true, nullable: true })
}), //schema.tons = new fields.NumberField({ required: false, initial: 0, min: 0, integer: false });
schema.damage = new fields.StringField({ required: false, blank: true, trim: true });
schema.magazine = new fields.NumberField({ required: false, initial: 0, min: 0, integer: true });
schema.magazineCost = new fields.NumberField({ required: false, initial: 0, min: 0, integer: true });
schema.traits = new fields.ArrayField(
new fields.SchemaField({
name: new fields.StringField({ required: true, blank: true, trim: true }),
description: new fields.StringField({ required: false, blank: true, trim: true })
})
);
schema.options = new fields.ArrayField(
new fields.SchemaField({
name: new fields.StringField({ required: true, blank: true, trim: true }),
description: new fields.StringField({ required: false, blank: true, trim: true })
})
);
return schema;
}
}
class ArmorData extends PhysicalItemData {
static defineSchema() {
const schema = super.defineSchema();
schema.equipped = new fields.BooleanField({ required: false, initial: false });
schema.radiations = new fields.NumberField({ required: false, initial: 0, min: 0, integer: true });
schema.protection = new fields.StringField({ required: false, blank: false, trim: true });
schema.requireSkill = new fields.StringField({ required: false, blank: false });
schema.requireSkillLevel = new fields.NumberField({ required: false, min: 0, integer: true });
schema.powered = new fields.BooleanField({ required: false, initial: false });
schema.options = new fields.ArrayField(
new fields.SchemaField({
name: new fields.StringField({ required: true, blank: true, trim: true }),
description: new fields.StringField({ required: false, blank: true, trim: true })
})
);
return schema;
}
}
class ComputerData extends PhysicalItemData {
static defineSchema() {
const schema = super.defineSchema();
schema.processing = new fields.NumberField({ required: false, initial: 0, min: 0, integer: true });
schema.processingUsed = new fields.NumberField({ required: false, initial: 0, min: 0, integer: true });
schema.overload = new fields.BooleanField({ required: false, initial: false });
schema.options = new fields.ArrayField(
new fields.SchemaField({
name: new fields.StringField({ required: true, blank: true, trim: true }),
description: new fields.StringField({ required: false, blank: true, trim: true })
})
);
return schema;
}
}
class SpeciesData extends ItemBaseData {
static defineSchema() {
const schema = super.defineSchema();
return schema;
}
}
class ItemContainerData extends ItemBaseData {
static defineSchema() {
const schema = super.defineSchema();
schema.onHand = new fields.BooleanField({ required: false, initial: false });
schema.location = new fields.StringField({ required: false, blank: true, trim: true });
schema.count = new fields.NumberField({ required: false, initial: 0, integer: true });
schema.weight = new fields.NumberField({ required: false, initial: 0, integer: false });
schema.weightless = new fields.BooleanField({ required: false, initial: false });
schema.locked = new fields.BooleanField({ required: false, initial: false });
schema.lockedDescription = new fields.StringField({ required: false, blank: true, trim: true, nullable: true });
return schema;
}
}
function createCharacteristicField(show = true, showMax = false) {
return new fields.SchemaField({
value: new fields.NumberField({ required: true, initial: 0, min: 0, integer: true }),
max: new fields.NumberField({ required: false, initial: 0, min: 0, integer: true }),
dm: new fields.NumberField({ required: false, initial: 0, integer: true }),
show: new fields.BooleanField({ required: false, initial: show }),
showMax: new fields.BooleanField({ required: false, initial: showMax })
});
}
const MGT2 = {};
MGT2.MetricRange = Object.freeze({
meter: "MGT2.MetricRange.meter",
kilometer: "MGT2.MetricRange.kilometer"
});
MGT2.MetricWeight = Object.freeze({
kilogram: "MGT2.MetricWeight.kilogram",
ton: "MGT2.MetricWeight.ton"
});
MGT2.Difficulty = Object.freeze({
NA: "MGT2.Difficulty.NA",
Simple: "MGT2.Difficulty.Simple",
Easy: "MGT2.Difficulty.Easy",
Routine: "MGT2.Difficulty.Routine",
Average: "MGT2.Difficulty.Average",
Difficult: "MGT2.Difficulty.Difficult",
VeryDifficult: "MGT2.Difficulty.VeryDifficult",
Formidable: "MGT2.Difficulty.Formidable",
Impossible: "MGT2.Difficulty.Impossible"
});
MGT2.ItemSubType = Object.freeze({
loot: "MGT2.ItemSubType.loot",
software: "MGT2.ItemSubType.software"
});
MGT2.EquipmentSubType = Object.freeze({
augment: "MGT2.EquipmentSubType.augment",
clothing: "MGT2.EquipmentSubType.clothing",
equipment: "MGT2.EquipmentSubType.equipment",
trinket: "MGT2.EquipmentSubType.trinket",
toolkit: "MGT2.EquipmentSubType.toolkit"
});
MGT2.TalentSubType = Object.freeze({
skill: "MGT2.TalentSubType.skill",
psionic: "MGT2.TalentSubType.psionic"
});
MGT2.DiseaseSubType = Object.freeze({
disease: "MGT2.DiseaseSubType.disease",
poison: "MGT2.DiseaseSubType.poison",
wound: "MGT2.DiseaseSubType.wound"
});
MGT2.PsionicReach = Object.freeze({
NA: "MGT2.PsionicReach.NA",
Personal: "MGT2.PsionicReach.Personal",
Close: "MGT2.PsionicReach.Close",
Short: "MGT2.PsionicReach.Short",
Medium: "MGT2.PsionicReach.Medium",
Long: "MGT2.PsionicReach.Long",
VeryLong: "MGT2.PsionicReach.VeryLong",
Distant: "MGT2.PsionicReach.Distant",
VeryDistant: "MGT2.PsionicReach.VeryDistant",
Continental: "MGT2.PsionicReach.Continental",
Planetary: "MGT2.PsionicReach.Planetary"
});
MGT2.ContactRelations = Object.freeze({
Allie: "MGT2.Contact.Relation.Allie",
Contact: "MGT2.Contact.Relation.Contact",
Rival: "MGT2.Contact.Relation.Rival",
Enemy: "MGT2.Contact.Relation.Enemy"
});
MGT2.ContactStatus = Object.freeze({
Alive: "MGT2.Contact.Status.Alive",
Unknow: "MGT2.Contact.Status.Unknow",
Dead: "MGT2.Contact.Status.Dead"
});
MGT2.Attitudes = Object.freeze({
Unknow: "MGT2.Contact.Attitude.Unknow",
Hostile: "MGT2.Contact.Attitude.Hostile",
Unfriendly: "MGT2.Contact.Attitude.Unfriendly",
Indifferent: "MGT2.Contact.Attitude.Indifferent",
Friendly: "MGT2.Contact.Attitude.Friendly",
Helpful: "MGT2.Contact.Attitude.Helpful",
Complicated: "MGT2.Contact.Attitude.Complicated"
});
MGT2.Characteristics = Object.freeze({
strength: "MGT2.Characteristics.strength.name",
dexterity: "MGT2.Characteristics.dexterity.name",
endurance: "MGT2.Characteristics.endurance.name",
intellect: "MGT2.Characteristics.intellect.name",
education: "MGT2.Characteristics.education.name",
social: "MGT2.Characteristics.social.name",
morale: "MGT2.Characteristics.morale.name",
luck: "MGT2.Characteristics.luck.name",
sanity: "MGT2.Characteristics.sanity.name",
charm: "MGT2.Characteristics.charm.name",
psionic: "MGT2.Characteristics.psionic.name",
other: "MGT2.Characteristics.other.name"
});
MGT2.InitiativeCharacteristics = Object.freeze({
dexterity: "MGT2.Characteristics.dexterity.name",
intellect: "MGT2.Characteristics.intellect.name"
});
MGT2.DamageCharacteristics = Object.freeze({
strength: "MGT2.Characteristics.strength.name",
dexterity: "MGT2.Characteristics.dexterity.name",
endurance: "MGT2.Characteristics.endurance.name"
});
MGT2.TL = Object.freeze({
NA: "MGT2.TL.NA",
Unknow: "MGT2.TL.Unknow",
NotIdentified: "MGT2.TL.NotIdentified",
TL00: "MGT2.TL.L00",
TL01: "MGT2.TL.L01",
TL02: "MGT2.TL.L02",
TL03: "MGT2.TL.L03",
TL04: "MGT2.TL.L04",
TL05: "MGT2.TL.L05",
TL06: "MGT2.TL.L06",
TL07: "MGT2.TL.L07",
TL08: "MGT2.TL.L08",
TL09: "MGT2.TL.L09",
TL10: "MGT2.TL.L10",
TL11: "MGT2.TL.L11",
TL12: "MGT2.TL.L12",
TL13: "MGT2.TL.L13",
TL14: "MGT2.TL.L14",
TL15: "MGT2.TL.L15"
});
MGT2.Timeframes = Object.freeze({
Normal: "MGT2.Timeframes.Normal",
Slower: "MGT2.Timeframes.Slower",
Faster: "MGT2.Timeframes.Faster"
});
MGT2.SpeedBands = Object.freeze({
Stoppped: "MGT2.Stoppped",
Idle: "MGT2.Idle",
VerySlow: "MGT2.VerySlow",
Slow: "MGT2.Slow",
Medium: "MGT2.Medium",
High: "MGT2.High.",
Fast: "MGT2.Fast",
VeryFast: "MGT2.VeryFast",
Subsonic: "MGT2.Subsonic",
Hypersonic: "MGT2.Hypersonic"
});
class ActorCharacter {
static preCreate($this, data, options, user) {
$this.updateSource({ prototypeToken: { actorLink: true } });
}
static prepareData(actorData) {
actorData.initiative = this.getInitiative(actorData);
}
static getInitiative($this) {
let c = $this.system.config.initiative;
return $this.system.characteristics[c].dm;
}
static async onDeleteDescendantDocuments($this, parent, collection, documents, ids, options, userId) {
const toDeleteIds = [];
const itemToUpdates = [];
for (let d of documents) {
if (d.type === "container") {
for (let item of $this.items) {
if (item.system.hasOwnProperty("container") && item.system.container.id === d._id)
toDeleteIds.push(item._id);
}
} else if (d.type === "computer") {
for (let item of $this.items) {
if (item.system.hasOwnProperty("software") && item.system.computerId === d._id) {
let clone = duplicate(item);
clone.system.software.computerId = "";
itemToUpdates.push(clone);
}
}
}
}
if (toDeleteIds.length > 0)
await $this.deleteEmbeddedDocuments("Item", toDeleteIds);
if (itemToUpdates.length > 0)
await $this.updateEmbeddedDocuments("Item", itemToUpdates);
await this.recalculateWeight();
}
static async onUpdateDescendantDocuments($this, parent, collection, documents, changes, options, userId) {
await this.calculEncumbranceAndWeight($this, parent, collection, documents, changes, options, userId);
await this.calculComputers($this, parent, collection, documents, changes, options, userId);
}
static async calculComputers($this, parent, collection, documents, changes, options, userId) {
let change;
let i = 0;
let recalculProcessing = false;
for (let d of documents) {
if (changes[i].hasOwnProperty("system")) {
change = changes[i];
if (d.type === "item" && d.system.subType === "software") {
if (change.system.software.hasOwnProperty("bandwidth") || change.system.software.hasOwnProperty("computerId")) {
recalculProcessing = true;
break;
}
}
}
}
if (recalculProcessing) {
let updatedComputers = [];
let computerChanges = {};
let computers = [];
for (let item of $this.items) {
if (item.system.trash === true)
continue;
if (item.type === "computer") {
computers.push(item);
computerChanges[item._id] = { processingUsed: 0 };
}
}
for (let item of $this.items) {
if (item.type !== "item" && item.system.subType !== "software")
continue;
if (item.system.software.hasOwnProperty("computerId") && item.system.software.computerId !== "") {
computerChanges[item.system.software.computerId].processingUsed += item.system.software.bandwidth;
}
}
for (let computer of computers) {
let newProcessingUsed = computerChanges[computer._id].processingUsed;
if (computer.system.processingUsed !== newProcessingUsed) {
const cloneComputer = duplicate($this.getEmbeddedDocument("Item", computer._id));
cloneComputer.system.processingUsed = newProcessingUsed;
cloneComputer.system.overload = cloneComputer.system.processingUsed > cloneComputer.system.processing;
updatedComputers.push(cloneComputer);
}
}
if (updatedComputers.length > 0) {
await $this.updateEmbeddedDocuments("Item", updatedComputers);
}
}
}
static async calculEncumbranceAndWeight($this, parent, collection, documents, changes, options, userId) {
var _a, _b;
let recalculEncumbrance = false;
let recalculWeight = false;
let change;
let i = 0;
for (let d of documents) {
if (changes[i].hasOwnProperty("system")) {
change = changes[i];
if (d.type === "armor" || d.type === "computer" || d.type === "gear" || d.type === "item" || d.type === "weapon") {
if (change.system.hasOwnProperty("quantity") || change.system.hasOwnProperty("weight") || change.system.hasOwnProperty("weightless") || change.system.hasOwnProperty("container") || change.system.hasOwnProperty("equipped") || d.type === "armor") {
recalculWeight = true;
}
} else if (d.type === "talent" && d.system.subType === "skill") {
if (change.system.level || ((_a = change.system) == null ? void 0 : _a.hasOwnProperty("skill")) && ((_b = change.system) == null ? void 0 : _b.skill.hasOwnProperty("reduceEncumbrance"))) {
recalculEncumbrance = true;
}
} else if (d.type === "container" && (change.system.hasOwnProperty("onHand") || change.system.hasOwnProperty("weightless"))) {
recalculWeight = true;
}
}
i++;
}
if (recalculEncumbrance || recalculWeight) {
const cloneActor = duplicate($this);
await this.recalculateArmor($this, cloneActor);
if (recalculEncumbrance) {
const str = $this.system.characteristics.strength.value;
const end = $this.system.characteristics.endurance.value;
let sumSkill = 0;
$this.items.filter((x) => x.type === "talent" && x.system.subType === "skill" && x.system.skill.reduceEncumbrance === true).forEach((x) => sumSkill += x.system.level);
let normal = str + end + sumSkill;
let heavy = normal * 2;
cloneActor.system.states.encumbrance = $this.system.inventory.weight > normal;
cloneActor.system.encumbrance.normal = normal;
cloneActor.system.encumbrance.heavy = heavy;
}
if (recalculWeight)
await this.recalculateWeight($this, cloneActor);
}
}
static async recalculateArmor($this, cloneActor) {
if (cloneActor === null || cloneActor === void 0)
cloneActor = duplicate($this);
let armor = 0;
for (let item of $this.items) {
if (item.type === "armor") {
if (item.system.equipped === true && !isNaN(item.system.protection)) {
armor += +item.system.protection || 0;
}
}
}
cloneActor.system.inventory.armor = armor;
}
static async recalculateWeight($this, cloneActor) {
if (cloneActor === null || cloneActor === void 0)
cloneActor = duplicate($this);
let updatedContainers = [];
let containerChanges = {};
let containers = [];
for (let item of $this.items) {
if (item.system.trash === true)
continue;
if (item.type === "container") {
containers.push(item);
containerChanges[item._id] = { count: 0, weight: 0 };
}
}
let onHandWeight = 0;
for (let item of $this.items) {
if (item.type === "container")
continue;
if (item.system.hasOwnProperty("weightless") && item.system.weightless === true)
continue;
let itemWeight = 0;
if (item.system.hasOwnProperty("weight")) {
let itemQty = item.system.quantity;
if (!isNaN(itemQty) && itemQty > 0) {
itemWeight = item.system.weight;
if (itemWeight > 0) {
itemWeight *= itemQty;
}
}
if (item.type === "armor") {
if (item.system.equipped === true) {
if (item.system.powered === true)
itemWeight = 0;
else
itemWeight *= 0.25;
}
}
if (item.system.container && item.system.container.id && item.system.container.id !== "") {
if (containerChanges.hasOwnProperty(item.system.container.id)) {
containerChanges[item.system.container.id].weight += Math.round(itemWeight * 10) / 10;
containerChanges[item.system.container.id].count += item.system.quantity;
}
} else {
onHandWeight += Math.round(itemWeight * 10) / 10;
}
}
}
for (let container of containers) {
let newWeight = containerChanges[container._id].weight;
let newCount = containerChanges[container._id].count;
if (container.system.weight !== newWeight || container.system.count !== newCount) {
const cloneContainer = duplicate($this.getEmbeddedDocument("Item", container._id));
cloneContainer.system.weight = newWeight;
cloneContainer.system.count = newCount;
updatedContainers.push(cloneContainer);
if (container.system.onHand === true && (container.system.weight > 0 || container.system.weightless !== true)) {
onHandWeight += container.system.weight;
}
}
}
cloneActor.system.inventory.weight = onHandWeight;
cloneActor.system.states.encumbrance = onHandWeight > $this.system.inventory.encumbrance.normal;
await $this.update(cloneActor);
if (updatedContainers.length > 0) {
await $this.updateEmbeddedDocuments("Item", updatedContainers);
}
}
static async preUpdate($this, changed, options, user) {
var _a, _b, _c, _d, _e, _f, _g, _h;
const newStr = (_a = foundry.utils.getProperty(changed, "system.characteristics.strength.value")) != null ? _a : $this.system.characteristics.strength.value;
const newEnd = (_b = foundry.utils.getProperty(changed, "system.characteristics.endurance.value")) != null ? _b : $this.system.characteristics.endurance.value;
if (newStr !== $this.system.characteristics.strength.value || newEnd !== $this.system.characteristics.endurance.value) {
let sumSkill = 0;
$this.items.filter((x) => x.type === "talent" && x.system.subType === "skill" && x.system.skill.reduceEncumbrance === true).forEach((x) => sumSkill += x.system.level);
let normal = newStr + newEnd + sumSkill;
let heavy = normal * 2;
foundry.utils.setProperty(changed, "system.inventory.encumbrance.normal", normal);
foundry.utils.setProperty(changed, "system.inventory.encumbrance.heavy", heavy);
}
const characteristicModified = this.computeCharacteristics(changed);
const strengthValue = (_c = foundry.utils.getProperty(changed, "system.characteristics.strength.value")) != null ? _c : $this.system.characteristics.strength.value;
const strengthMax = (_d = foundry.utils.getProperty(changed, "system.characteristics.strength.max")) != null ? _d : $this.system.characteristics.strength.max;
const dexterityValue = (_e = foundry.utils.getProperty(changed, "system.characteristics.dexterity.value")) != null ? _e : $this.system.characteristics.dexterity.value;
const dexterityMax = (_f = foundry.utils.getProperty(changed, "system.characteristics.dexterity.max")) != null ? _f : $this.system.characteristics.dexterity.max;
const enduranceValue = (_g = foundry.utils.getProperty(changed, "system.characteristics.endurance.value")) != null ? _g : $this.system.characteristics.endurance.value;
const enduranceMax = (_h = foundry.utils.getProperty(changed, "system.characteristics.endurance.max")) != null ? _h : $this.system.characteristics.endurance.max;
const lifeValue = strengthValue + dexterityValue + enduranceValue;
const lifeMax = strengthMax + dexterityMax + enduranceMax;
if ($this.system.life.value !== lifeValue)
foundry.utils.setProperty(changed, "system.life.value", lifeValue);
if ($this.system.life.max !== lifeMax)
foundry.utils.setProperty(changed, "system.life.max", lifeMax);
if (characteristicModified && $this.system.personal.ucp === void 0 || $this.system.personal.ucp === "") ;
}
// static applyHealing($this, amount) {
// if (isNaN(amount) || amount === 0) return;
// const strength = $this.system.characteristics.strength;
// const dexterity = $this.system.characteristics.dexterity;
// const endurance = $this.system.characteristics.endurance;
// const data = {
// strength: { value: strength.value },
// dexterity: { value: dexterity.value },
// endurance: { value: endurance.value }
// };
// $this.update({ system: { characteristics: data } });
// }
static applyDamage($this, amount) {
if (isNaN(amount) || amount === 0)
return;
const rank1 = $this.system.config.damages.rank1;
const rank2 = $this.system.config.damages.rank2;
const rank3 = $this.system.config.damages.rank3;
const data = {};
data[rank1] = { value: $this.system.characteristics[rank1].value };
data[rank2] = { value: $this.system.characteristics[rank2].value };
data[rank3] = { value: $this.system.characteristics[rank3].value };
if (amount < 0)
amount = Math.abs(amount);
for (const [key, rank] of Object.entries(data)) {
if (rank.value > 0) {
if (rank.value >= amount) {
rank.value -= amount;
amount = 0;
} else {
amount -= rank.value;
rank.value = 0;
}
rank.dm = this.getModifier(rank.value);
if (amount <= 0)
break;
}
}
$this.update({ system: { characteristics: data } });
}
static getContainers($this) {
const containers = [];
for (let item of $this.items) {
if (item.type == "container") {
containers.push(item);
}
}
containers.sort(this.compareByName);
return containers;
}
static getComputers($this) {
const containers = [];
for (let item of $this.items) {
if (item.type == "computer") {
containers.push(item);
}
}
containers.sort(this.compareByName);
return containers;
}
static getSkills($this) {
const skills = [];
for (let item of $this.items) {
if (item.type === "talent" && item.system.subType === "skill") {
skills.push(item);
}
}
skills.sort(this.compareByName);
return skills;
}
static computeCharacteristics(changed) {
let modified = this.computeCharacteristic(changed, "strength");
if (this.computeCharacteristic(changed, "dexterity") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "endurance") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "intellect") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "education") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "social") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "morale") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "luck") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "sanity") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "charm") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "psionic") && !modified)
modified = true;
if (this.computeCharacteristic(changed, "other") && !modified)
modified = true;
return modified;
}
static computeCharacteristic(changed, name) {
const path = `system.characteristics.${name}`;
const newValue = foundry.utils.getProperty(changed, path + ".value");
if (newValue) {
const dm = this.getModifier(newValue);
foundry.utils.setProperty(changed, path + ".dm", dm);
return true;
}
return false;
}
static getModifier(value) {
if (isNaN(value) || value <= 0)
return -3;
if (value >= 1 && value <= 2)
return -2;
if (value >= 3 && value <= 5)
return -1;
if (value >= 6 && value <= 8)
return 0;
if (value >= 9 && value <= 11)
return 1;
if (value >= 12 && value <= 14)
return 2;
return 3;
}
static compareByName(a, b) {
if (!a.hasOwnProperty("name") || !b.hasOwnProperty("name")) {
return 0;
}
return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
}
}
class MGT2Combatant extends Combatant {
}
class TravellerActor extends Actor {
// _onUpdate(data, options, userId) {
// super._onUpdate(data, options, userId);
// console.log("_onUpdate");
// console.log(data);
// if (data.system?.characteristics) {
// // Calc encumbrance
// if (data.system.characteristics.strength || data.system.characteristics.endurance) {
// data.system.encumbrance.normal = 0;
// data.system.encumbrance.heavy = 0;
// }
// }
// // If benefits were changed
// //if (data.system?.benefits) {
// // this.updateBenefitsOnActor();
// //}
// // this.actor.computeCharacteristics(formData);
// }
/*
initiative if(!token?.combatant) return ui.notifications.warn("You are missing a selected token or combatant."); const bonus = await Dialog.prompt({ title: "Roll Initiative", content: `<input type="number" placeholder="Initiative bonus" autofocus>`, callback: (html) => html[0].querySelector("input").value, rejectClose: false }); const roll = await new Roll(`1d12 + ${bonus}`).evaluate({async: true}); await roll.toMessage({ flavor: `${token.actor.name} rolls initiative!`, speaker: ChatMessage.getSpeaker({actor: token.actor}) }); await token.combatant.update({initiative: roll.total});
*/
prepareDerivedData() {
if (this.type === "character") {
this.system.initiative = ActorCharacter.getInitiative(this);
}
}
async _preCreate(data, options, user) {
if (await super._preCreate(data, options, user) === false)
return false;
if (this.type === "character") {
ActorCharacter.preCreate(this, data, options, user);
}
}
async _onDeleteDescendantDocuments(parent, collection, documents, ids, options, userId) {
await super._onDeleteDescendantDocuments(parent, collection, documents, ids, options, userId);
if (this.type === "character") {
await ActorCharacter.onDeleteDescendantDocuments(this, parent, collection, documents, ids, options, userId);
}
}
async _onUpdateDescendantDocuments(parent, collection, documents, changes, options, userId) {
super._onUpdateDescendantDocuments(parent, collection, documents, changes, options, userId);
if (this.type === "character") {
await ActorCharacter.onUpdateDescendantDocuments(this, parent, collection, documents, changes, options, userId);
}
}
async _preUpdate(changed, options, user) {
if (await super._preUpdate(changed, options, user) === false)
return false;
if (this.type === "character") {
await ActorCharacter.preUpdate(this, changed, options, user);
}
}
getInitiative($this) {
if (this.type === "character") {
return ActorCharacter.getInitiative(this);
}
}
applyDamage(amount) {
if (this.type === "character") {
ActorCharacter.applyDamage(this, amount);
}
}
getContainers() {
if (this.type === "character") {
return ActorCharacter.getContainers(this);
}
return [];
}
getComputers() {
if (this.type === "character") {
return ActorCharacter.getComputers(this);
}
return [];
}
getSkills() {
if (this.type === "character") {
return ActorCharacter.getSkills(this);
}
return [];
}
}
class TravellerItem extends Item {
/** @inheritdoc */
prepareDerivedData() {
super.prepareDerivedData();
}
async _preUpdate(changed, options, user) {
var _a, _b, _c;
if (await super._preUpdate(changed, options, user) === false)
return false;
if (this.type === "computer") {
const newProcessing = (_a = foundry.utils.getProperty(changed, "system.processing")) != null ? _a : this.system.processing;
if (newProcessing !== this.system.processing) {
let overload = this.system.processingUsed > newProcessing;
foundry.utils.setProperty(changed, "system.overload", overload);
}
}
if (this.type === "computer" || this.type === "container" || this.type === "item" && this.system.subType === "software") {
const newQty = (_b = foundry.utils.getProperty(changed, "system.quantity")) != null ? _b : this.system.quantity;
if (newQty !== this.system.quantity && newQty > 1) {
foundry.utils.setProperty(changed, "system.quantity", 1);
}
}
if (this.type === "item" && this.system.subType === "software") {
const newWeight = (_c = foundry.utils.getProperty(changed, "system.weight")) != null ? _c : this.system.weight;
if (newWeight !== this.system.weight && newWeight > 0) {
foundry.utils.setProperty(changed, "system.weight", 0);
}
}
}
getRollDisplay() {
if (this.type === "talent") {
if (this.system.subType === "skill") {
let label;
if (this.system.skill.speciality !== "" && this.system.skill.speciality !== void 0) {
label = `${this.name} (${this.system.skill.speciality})`;
} else {
label = this.name;
}
if (this.system.level > 0)
label += ` (+${this.system.level})`;
else if (this.system.level < 0)
label += ` (${this.system.level})`;
return label;
} else if (this.system.subType === "psionic") ;
}
return name;
}
}
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
const _MGT2Helper = class _MGT2Helper {
static getItemsWeight(items) {
let weight = 0;
for (let i of items) {
let item = i.hasOwnProperty("system") ? i.system : i;
if (item.hasOwnProperty("weightless") && item.weightless === true) {
continue;
}
if (item.hasOwnProperty("weight")) {
let itemQty = item.quantity;
if (!isNaN(itemQty) && itemQty > 0) {
let itemWeight = item.weight;
if (itemWeight > 0) {
weight += itemWeight * itemQty;
}
}
}
}
return weight;
}
static generateUID() {
let result = "";
const characters = "abcdefghijklmnopqrstuvwxyz0123456789";
for (let i = 0; i < 36; i++) {
const randomIndex = Math.floor(Math.random() * characters.length);
result += characters.charAt(randomIndex);
if (i === 8 || i === 12 || i === 16 || i === 20)
result += "-";
}
return result;
}
static compareByName(a, b) {
if (!a.hasOwnProperty("name") || !b.hasOwnProperty("name")) {
return 0;
}
return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
}
static getDisplayDM(dm) {
if (dm === 0)
return " (0)";
if (dm > 0)
return ` (+${dm})`;
if (dm < 0)
return ` (${dm})`;
return "";
}
static getFormulaDM(dm) {
if (dm === 0)
return "+0";
if (dm > 0)
return `+${dm}`;
if (dm < 0)
return `${dm}`;
return "";
}
static getDiceResults(roll) {
const results = [];
for (const die of roll.dice) {
results.push(die.results);
}
return results.flat(2);
}
static getDiceTotal(roll) {
let total = 0;
for (const die of roll.dice) {
total += die.total;
}
return total;
}
static getRangeDisplay(range) {
let value = Number(range.value);
if (isNaN(value))
return null;
let label;
if (game.settings.get("mgt2", "useDistanceMetric") === true) {
if (range.unit !== null && range.unit !== void 0 && range.unit !== "")
label = game.i18n.localize(`MGT2.MetricRange.${range.unit}`).toLowerCase();
else
label = "";
}
return `${value}${label}`;
}
static getWeightLabel() {
const label = game.settings.get("mgt2", "useWeightMetric") === true ? "MGT2.MetricSystem.Weight.kg" : "MGT2.ImperialSystem.Weight.lb";
return game.i18n.localize(label);
}
static getDistanceLabel() {
const label = game.settings.get("mgt2", "useDistanceMetric") === true ? "MGT2.MetricSystem.Distance.km" : "MGT2.ImperialSystem.Distance.mi";
return game.i18n.localize(label);
}
static getIntegerFromInput(data) {
return Math.trunc(this.getNumberFromInput(data));
}
static getNumberFromInput(data) {
if (data === void 0 || data === null)
return 0;
if (typeof data === "string") {
let converted2 = Number(data.replace(/\s+/g, "").replace(this.badDecimalSeparator, this.decimalSeparator).trim());
if (isNaN(converted2))
return 0;
return converted2;
}
let converted = Number(data);
if (isNaN(converted))
return 0;
return converted;
}
static convertWeightForDisplay(weight) {
if (game.settings.get("mgt2", "useWeightMetric") === true || weight === 0)
return weight;
const pounds = weight * this.POUNDS_CONVERT;
return Math.round(pounds * 10) / 10;
}
static convertWeightFromInput(weight) {
if (game.settings.get("mgt2", "useWeightMetric") === true || weight === 0)
return Math.round(weight * 10) / 10;
const kg = this.POUNDS_CONVERT / weight;
return Math.round(kg * 10) / 10;
}
static getDataFromDropEvent(event) {
var _a;
try {
return JSON.parse((_a = event.dataTransfer) == null ? void 0 : _a.getData("text/plain"));
} catch (err) {
return false;
}
}
static async getItemDataFromDropData(dropData) {
var _a;
let item;
if (((_a = game.modules.get("monks-enhanced-journal")) == null ? void 0 : _a.active) && dropData.itemId && dropData.uuid.includes("JournalEntry")) {
await fromUuid(dropData.uuid);
} else if (dropData.hasOwnProperty("uuid")) {
item = await fromUuid(dropData.uuid);
} else {
let uuid = `${dropData.type}.${dropData.data._id}`;
item = await fromUuid(uuid);
}
if (!item) {
throw new Error(game.i18n.localize("Errors.CouldNotFindItem").replace("_ITEM_ID_", dropData.uuid));
}
if (item.pack) {
const pack = game.packs.get(item.pack);
item = await (pack == null ? void 0 : pack.getDocument(item._id));
}
return deepClone(item);
}
};
__publicField(_MGT2Helper, "POUNDS_CONVERT", 2.20462262185);
__publicField(_MGT2Helper, "decimalSeparator");
__publicField(_MGT2Helper, "badDecimalSeparator");
_MGT2Helper.decimalSeparator = Number(1.1).toLocaleString().charAt(1);
_MGT2Helper.badDecimalSeparator = _MGT2Helper.decimalSeparator === "." ? "," : ".";
let MGT2Helper = _MGT2Helper;
class TravellerItemSheet extends ItemSheet {
/** @inheritdoc */
static get defaultOptions() {
const options = super.defaultOptions;
return foundry.utils.mergeObject(options, {
classes: ["mgt2", game.settings.get("mgt2", "theme"), "sheet"],
width: 630,
tabs: [{ navSelector: ".horizontal-tabs", contentSelector: ".itemsheet-panel", initial: "tab1" }]
});
}
/* -------------------------------------------- */
get template() {
const path = "systems/mgt2/templates/items";
return `${path}/${this.item.type}-sheet.html`;
}
/** @inheritdoc */
async getData(options) {
const context = await super.getData(options);
const item = context.item;
const source = item.toObject();
context.config = CONFIG.MGT2;
const settings = {};
settings.usePronouns = game.settings.get("mgt2", "usePronouns");
let containers = null;
let computers = null;
let hadContainer;
if (context.item.actor != null) {
hadContainer = true;
containers = [{ "name": "", "_id": "" }].concat(context.item.actor.getContainers());
computers = [{ "name": "", "_id": "" }].concat(context.item.actor.getComputers());
} else {
hadContainer = false;
}
let weight = null;
if (item.system.hasOwnProperty("weight")) {
weight = MGT2Helper.convertWeightForDisplay(item.system.weight);
}
let unitlabels = {
weight: MGT2Helper.getWeightLabel()
};
let skills = [];
if (this.actor !== null) {
for (let item2 of this.actor.items) {
if (item2.type === "talent") {
if (item2.system.subType === "skill")
skills.push({ _id: item2._id, name: item2.getRollDisplay() });
}
}
}
skills.sort(MGT2Helper.compareByName);
skills = [{ _id: "NP", name: game.i18n.localize("MGT2.Items.NotProficient") }].concat(skills);
foundry.utils.mergeObject(context, {
source: source.system,
system: item.system,
settings,
containers,
computers,
hadContainer,
weight,
unitlabels,
editable: this.isEditable,
isGM: game.user.isGM,
skills,
config: CONFIG
//rollData: this.item.getRollData(),
});
return context;
}
/* -------------------------------------------- */
/** @inheritdoc */
activateListeners(html) {
super.activateListeners(html);
if (!this.isEditable)
return;
html.find("div.itemsheet-panel").each((i, li) => {
});
if (this.item.type == "career") {
html.find(".event-create").click(this._onCareerEventCreate.bind(this));
html.find(".event-delete").click(this._onCareerEventDelete.bind(this));
} else if (this.item.type == "armor" || this.item.type == "computer" || this.item.type == "weapon") {
html.find(".options-create").click(this._onOptionCreate.bind(this));
html.find(".options-delete").click(this._onOptionDelete.bind(this));
}
}
async _onCareerEventCreate(event) {
event.preventDefault();
await this._onSubmit(event);
let events = this.item.system.events;
let index;
if (events.length === 0) {
events = {};
events["0"] = { age: "", description: "" };
} else {
index = Math.max(...Object.keys(events));
index++;
events[index] = { age: "", description: "" };
}
let update = {
system: {
events
}
};
return this.item.update(update);
}
async _onCareerEventDelete(event) {
event.preventDefault();
await this._onSubmit(event);
const element = event.currentTarget.closest(".events-part");
const events = foundry.utils.deepClone(this.item.system.events);
let index = Number(element.dataset.eventsPart);
const newEvents = [];
let entries = Object.entries(events);
if (entries.length > 1) {
for (const [key, value] of entries) {
if (key != index)
newEvents.push(value);
}
}
let update = {
system: {
events: newEvents
}
};
return this.item.update(update);
}
async _onOptionCreate(event) {
event.preventDefault();
await this._onSubmit(event);
const property = event.currentTarget.dataset.property;
let options = this.item.system[property];
let index;
if (options.length === 0) {
options = {};
options["0"] = { name: "", description: "" };
} else {
index = Math.max(...Object.keys(options));
index++;
options[index] = { name: "", description: "" };
}
let update = {};
update[`system.${property}`] = options;
return this.item.update(update);
}
async _onOptionDelete(event) {
event.preventDefault();
await this._onSubmit(event);
const element = event.currentTarget.closest(".options-part");
const property = element.dataset.property;
const options = foundry.utils.deepClone(this.item.system[property]);
let index = Number(element.dataset.optionsPart);
const newOptions = [];
let entries = Object.entries(options);
if (entries.length > 1) {
for (const [key, value] of entries) {
if (key != index)
newOptions.push(value);
}
}
let update = {};
update[`system.${property}`] = newOptions;
return this.item.update(update);
}
async _onTraitCreate(event) {
event.preventDefault();
await this._onSubmit(event);
const traits = this.item.system.traits;
return this.item.update({ "system.traits.parts": traits.parts.concat([["", ""]]) });
}
async _onTraitDelete(event) {
event.preventDefault();
await this._onSubmit(event);
const element = event.currentTarget.closest(".traits-part");
const traits = foundry.utils.deepClone(this.item.system.traits);
traits.parts.splice(Number(element.dataset.traitsPart), 1);
return this.item.update({ "system.traits.parts": traits.parts });
}
_getSubmitData(updateData = {}) {
const formData = foundry.utils.expandObject(super._getSubmitData(updateData));
if (formData.hasOwnProperty("system") && formData.system.hasOwnProperty("container") && this.item.system.hasOwnProperty("equipped")) {
const equippedChange = this.item.system.equipped !== formData.system.equipped;
const containerChange = this.item.system.container.id !== formData.system.container.id;
if (equippedChange) {
if (formData.system.equipped === true) {
formData.system.container = {
//inContainer: false,
id: ""
};
}
} else if (containerChange) {
if (formData.system.container.id !== "" && (this.item.system.container.id === "" || this.item.system.container.id === null)) {
formData.system.equipped = false;
}
}
}
if (formData.hasOwnProperty("weight")) {
formData.system.weight = MGT2Helper.convertWeightFromInput(formData.weight);
delete formData.weight;
}
if (formData.system.hasOwnProperty("quantity")) {
formData.system.quantity = MGT2Helper.getIntegerFromInput(formData.system.quantity);
}
if (formData.system.hasOwnProperty("cost")) {
formData.system.cost = MGT2Helper.getIntegerFromInput(formData.system.cost);
}
return foundry.utils.flattenObject(formData);
}
}
class RollPromptDialog extends Dialog {
constructor(dialogData = {}, options = {}) {
super(dialogData, options);
this.options.classes = ["mgt2", game.settings.get("mgt2", "theme"), "sheet", "dialog"];
}
static async create(options) {
const htmlContent = await renderTemplate("systems/mgt2/templates/roll-prompt.html", {
config: CONFIG.MGT2,
//formula: formula,
characteristics: options.characteristics,
characteristic: options.characteristic,
skills: options.skills,
skill: options.skill,
fatigue: options.fatigue,
encumbrance: options.encumbrance
});
const results = new Promise((resolve) => {
new this({
title: options.title,
content: htmlContent,
buttons: {
boon: {
label: game.i18n.localize("MGT2.RollPrompt.Boon"),
callback: (html) => {
const formData = new FormDataExtended(html[0].querySelector("form")).object;
formData.diceModifier = "dl";
resolve(formData);
}
},
submit: {
label: game.i18n.localize("MGT2.RollPrompt.Roll"),
icon: '<i class="fa-solid fa-dice"></i>',
callback: (html) => {
const formData = new FormDataExtended(html[0].querySelector("form")).object;
resolve(formData);
}
},
bane: {
label: game.i18n.localize("MGT2.RollPrompt.Bane"),
//icon: '<i class="fa-solid fa-dice"></i>',
callback: (html) => {
const formData = new FormDataExtended(html[0].querySelector("form")).object;
formData.diceModifier = "dh";
resolve(formData);
}
}
}
//close: () => { resolve(false) }
}).render(true);
});
return results;
}
}
class RollPromptHelper {
static async roll(options) {
return await RollPromptDialog.create(options);
}
static async promptForFruitTraits() {
const htmlContent = await renderTemplate("systems/mgt2/templateschat/chat/roll-prompt.html");
return new Promise((resolve, reject) => {
const dialog = new Dialog({
title: "Fruit Traits",
content: htmlContent,
buttons: {
submit: {
label: "Roll",
icon: '<i class="fa-solid fa-dice"></i>',
callback: (html) => {
const formData = new FormDataExtended(html[0].querySelector("form")).toObject();
resolve(formData);
}
},
skip: {
label: "Cancel",
callback: () => resolve(null)
}
},
render: (html) => {
},
close: () => {
reject("User closed dialog without making a selection.");
}
});
dialog.render(true);
});
}
}
class ActorConfigDialog extends Dialog {
constructor(dialogData = {}, options = {}) {
super(dialogData, options);
this.options.classes = ["mgt2", game.settings.get("mgt2", "theme"), "sheet"];
}
static async create(system) {
const htmlContent = await renderTemplate("systems/mgt2/templates/actors/actor-config-sheet.html", {
config: CONFIG.MGT2,
system
});
const results = new Promise((resolve) => {
new this({
title: "Configuration",
content: htmlContent,
buttons: {
submit: {
label: "Save",
icon: '<i class="fa-solid fa-floppy-disk"></i>',
callback: (html) => {
const formData = new FormDataExtended(html[0].querySelector("form")).object;
resolve(formData);
}
}
}
}).render(true);
});
return results;
}
}
class CharacterPrompts {
static async openConfig(system) {
return await ActorConfigDialog.create(system);
}
static async openCharacteristic(name, hide, showMax, showAll = false) {
return await ActorCharacteristicDialog.create(name, hide, showMax, showAll);
}
}
class ActorCharacteristicDialog extends Dialog {
// https://foundryvtt.wiki/en/development/api/dialog
constructor(dialogData = {}, options = {}) {
super(dialogData, options);
this.options.classes = ["mgt2", game.settings.get("mgt2", "theme"), "sheet"];
}
static async create(name, show, showMax, showAll = false) {
const htmlContent = await renderTemplate("systems/mgt2/templates/actors/actor-config-characteristic-sheet.html", {
name,
show,
showMax,
showAll
});
const results = new Promise((resolve) => {
new this({
title: "Configuration: " + name,
content: htmlContent,
buttons: {
submit: {
label: "Save",
icon: '<i class="fa-solid fa-floppy-disk"></i>',
callback: (html) => {
const formData = new FormDataExtended(html[0].querySelector("form")).object;
resolve(formData);
}
}
}
}).render(true);
});
return results;
}
}
class TravellerActorSheet extends ActorSheet {
/** @inheritdoc */
static get defaultOptions() {
const options = super.defaultOptions;
if (game.user.isGM || options.editable)
options.dragDrop.push({ dragSelector: ".drag-item-list", dropSelector: ".drop-item-list" });
return foundry.utils.mergeObject(options, {
classes: ["mgt2", game.settings.get("mgt2", "theme"), "sheet", "actor", "character", "nopad"],
template: "systems/mgt2/templates/actors/actor-sheet.html",
width: 780,
//height: 600,
tabs: [
{ navSelector: ".sheet-sidebar", contentSelector: "form" },
{ navSelector: "nav[data-group='characteristics']", contentSelector: "section.characteristics-panel", initial: "core" },
{ navSelector: "nav[data-group='inventory']", contentSelector: "div.tab[data-tab='inventory']", initial: "onhand" }
]
});
}
async getData(options) {
const context = super.getData(options);
this._prepareCharacterItems(context);
return context.data;
}
_prepareCharacterItems(sheetData) {
const actorData = sheetData.data;
actorData.isGM = game.user.isGM;
actorData.showTrash = false;
actorData.initiative = this.actor.getInitiative();
const weapons = [];
const armors = [];
const augments = [];
const computers = [];
const softwares = [];
const items = [];
const equipments = [];
const containerItems = [];
const careers = [];
const skills = [];
const psionics = [];
const diseases = [];
const wounds = [];
const contacts = [];
const settings = {
weightUnit: game.settings.get("mgt2", "useWeightMetric") ? "kg" : "lb",
usePronouns: game.settings.get("mgt2", "usePronouns"),
useGender: game.settings.get("mgt2", "useGender"),
showLife: game.settings.get("mgt2", "showLife")
};
actorData.settings = settings;
const actorContainers = [];
for (let item of sheetData.items) {
if (item.type === "container") {
actorContainers.push(item);
} else if (item.type === "computer") {
computers.push(item);
item.subItems = [];
if (item.system.overload === true)
item.overloadClass = "computer-overload";
}
}
actorContainers.sort(MGT2Helper.compareByName);
const containers = [{ "name": "(tous)", "_id": "" }].concat(actorContainers);
const containerIndex = /* @__PURE__ */ new Map();
for (let c of actorContainers) {
containerIndex.set(c._id, c);
if (c.system.weight > 0) {
c.weight = MGT2Helper.convertWeightForDisplay(c.system.weight) + " " + settings.weightUnit;
c.display = c.name.length > 12 ? `${c.name.substring(0, 12)}... (${c.weight})` : `${c.name} (${c.weight})`;
} else {
c.display = c.name.length > 12 ? c.name.substring(0, 12) + "..." : c.name;
}
if (c.system.onHand === true)
c.subItems = [];
}
let currentContainerView;
if (actorData.system.containerView !== "") {
currentContainerView = containerIndex.get(actorData.system.containerView);
if (currentContainerView !== void 0) {
actorData.containerView = currentContainerView;
actorData.containerWeight = MGT2Helper.convertWeightForDisplay(currentContainerView.system.weight);
} else {
currentContainerView = null;
actorData.containerWeight = MGT2Helper.convertWeightForDisplay(0);
}
} else {
currentContainerView = null;
actorData.containerWeight = MGT2Helper.convertWeightForDisplay(0);
}
actorData.containerShowAll = actorData.system.containerView === "";
for (let i of sheetData.items) {
let item = i.system;
if (i.system.hasOwnProperty("weight") && i.system.weight > 0) {
if (isNaN(i.system.quantity))
i.weight = MGT2Helper.convertWeightForDisplay(i.system.weight) + " " + settings.weightUnit;
else
i.weight = MGT2Helper.convertWeightForDisplay(i.system.weight * i.system.quantity) + " " + settings.weightUnit;
}
if (item.hasOwnProperty("container") && item.container.id !== "" && item.container.id !== void 0) {
let container = containerIndex.get(item.container.id);
if (container === void 0) {
if (actorData.containerShowAll) {
i.containerName = "#deleted#";
containerItems.push(i);
}
continue;
}
if (container.system.locked && !game.user.isGM)
continue;
if (container.system.onHand === true) {
container.subItems.push(i);
}
if (actorData.containerShowAll || !actorData.containerShowAll && actorData.system.containerView == item.container.id) {
if (container === void 0)
i.containerName = "#deleted#";
else
i.containerName = container.name;
containerItems.push(i);
}
continue;
}
if (i.system.hasOwnProperty("equipped")) {
i.canEquip = true;
if (i.system.equipped === true)
i.toggleClass = "active";
} else {
i.canEquip = false;
}
switch (i.type) {
case "equipment":
switch (i.system.subType) {
case "augment":
augments.push(i);
break;
default:
equipments.push(i);
break;
}
break;
case "armor":
armors.push(i);
if (i.system.options && i.system.options.length > 0) {
i.subInfo = i.system.options.map((x) => x.name).join(", ");
}
break;
case "computer":
if (i.system.options && i.system.options.length > 0) {
i.subInfo = i.system.options.map((x) => x.name).join(", ");
}
break;
case "item":
if (i.system.subType === "software") {
if (i.system.software.computerId && i.system.software.computerId !== "") {
const computer = computers.find((x) => x._id === i.system.software.computerId);
if (computer !== void 0)
computer.subItems.push(i);
else
softwares.push(i);
} else {
if (i.system.software.bandwidth > 0)
i.display = `${i.name} (${i.system.software.bandwidth})`;
else
i.display = i.name;
softwares.push(i);
}
} else {
items.push(i);
}
break;
case "weapon":
if (i.system.range.isMelee)
i.range = game.i18n.localize("MGT2.Melee");
else {
i.range = MGT2Helper.getRangeDisplay(i.system.range);
}
if (i.system.traits && i.system.traits.length > 0) {
i.subInfo = i.system.traits.map((x) => x.name).join(", ");
}
weapons.push(i);
break;
case "career":
careers.push(i);
break;
case "contact":
contacts.push(i);
break;
case "disease":
switch (i.system.subType) {
case "wound":
wounds.push(i);
break;
default:
diseases.push(i);
break;
}
break;
case "talent":
if (i.system.subType === "skill") {
skills.push(i);
} else {
psionics.push(i);
}
break;
case "container":
if (i.system.onHand === true) {
items.push(i);
}
break;
}
}
actorData.encumbranceNormal = MGT2Helper.convertWeightForDisplay(actorData.system.inventory.encumbrance.normal);
actorData.encumbranceHeavy = MGT2Helper.convertWeightForDisplay(actorData.system.inventory.encumbrance.heavy);
if (actorData.system.inventory.weight > actorData.system.inventory.encumbrance.heavy) {
actorData.encumbranceClasses = "encumbrance-heavy";
actorData.encumbrance = 2;
} else if (actorData.system.inventory.weight > actorData.system.inventory.encumbrance.normal) {
actorData.encumbranceClasses = "encumbrance-normal";
actorData.encumbrance = 1;
} else {
actorData.encumbrance = 0;
}
if (softwares.length > 0) {
softwares.sort(MGT2Helper.compareByName);
actorData.softwares = softwares;
}
augments.sort(this.compareEquippedByName);
actorData.augments = augments;
armors.sort(this.compareEquippedByName);
actorData.armors = armors;
computers.sort(this.compareEquippedByName);
actorData.computers = computers;
actorData.careers = careers;
contacts.sort(MGT2Helper.compareByName);
actorData.contacts = contacts;
containers.sort(MGT2Helper.compareByName);
actorData.containers = containers;
diseases.sort(MGT2Helper.compareByName);
actorData.diseases = diseases;
actorData.wounds = wounds;
equipments.sort(this.compareEquippedByName);
actorData.equipments = equipments;
items.sort(this.compareEquippedByName);
actorData.items = items;
actorContainers.sort(MGT2Helper.compareByName);
actorData.actorContainers = actorContainers;
skills.sort(MGT2Helper.compareByName);
actorData.skills = skills;
psionics.sort(MGT2Helper.compareByName);
actorData.psionics = psionics;
weapons.sort(this.compareEquippedByName);
actorData.weapons = weapons;
if (containerItems.length > 0) {
containerItems.sort((a, b) => {
const containerResult = a.containerName.localeCompare(b.containerName);
if (containerResult !== 0)
return containerResult;
return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
});
}
actorData.containerItems = containerItems;
}
compareEquippedByName(a, b) {
return a.name.toLowerCase().localeCompare(b.name.toLowerCase());
}
activateListeners(html) {
super.activateListeners(html);
if (!this.options.editable)
return;
html.find(".container-create").click(this._onContainerCreate.bind(this));
html.find(".container-edit").click((ev) => {
const container = this.actor.getEmbeddedDocument("Item", this.actor.system.containerView);
container.sheet.render(true);
});
html.find(".container-delete").click((ev) => {
ev.preventDefault();
const containers = this.actor.getContainers();
const container = containers.find((x) => x._id == this.actor.system.containerView);
const containerItems = this.actor.items.filter((x) => x.system.hasOwnProperty("container") && x.system.container.id === container._id);
if (containerItems.length > 0) {
for (let item of containerItems) {
let clone = duplicate(item);
clone.system.container.id = "";
this.actor.updateEmbeddedDocuments("Item", [clone]);
}
}
const cloneActor = duplicate(this.actor);
cloneActor.system.containerView = "";
if (cloneActor.system.containerDropIn === container._id) {
cloneActor.system.containerDropIn = "";
const remainingContainers = containers.filter((x) => x._id !== container._id);
if (remainingContainers.length > 0)
cloneActor.system.containerDropIn = remainingContainers[0]._id;
}
this.actor.deleteEmbeddedDocuments("Item", [container._id]);
this.actor.update(cloneActor);
});
html.find(".item-create").click(this._onItemCreate.bind(this));
html.find(".item-edit").click((ev) => {
ev.preventDefault();
const html2 = $(ev.currentTarget).parents("[data-item-id]");
const item = this.actor.getEmbeddedDocument("Item", html2.data("itemId"));
item.sheet.render(true);
});
html.find(".item-delete").click((ev) => {
ev.preventDefault();
const html2 = $(ev.currentTarget).parents("[data-item-id]");
this.actor.deleteEmbeddedDocuments("Item", [html2.data("itemId")]);
html2.slideUp(200, () => this.render(false));
});
html.find("a.item-equip").click(this._onItemEquip.bind(this));
html.find("a.item-storage-out").click(this._onItemStorageOut.bind(this));
html.find("a.item-storage-in").click(this._onItemStorageIn.bind(this));
html.find("a.software-eject").click(this._onSoftwareEject.bind(this));
html.find("a[data-roll]").click(this._onRoll.bind(this));
html.find('a[name="config"]').click(this._onOpenConfig.bind(this));
html.find("a[data-cfg-characteristic]").click(this._onOpenCharacteristic.bind(this));
}
async _onOpenConfig(ev) {
ev.preventDefault();
const userConfig = await CharacterPrompts.openConfig(this.actor.system);
if (userConfig) {
this.actor.update({ "system.config": userConfig });
}
}
async _onOpenCharacteristic(ev) {
ev.preventDefault();
const name = ev.currentTarget.dataset.cfgCharacteristic;
const c = this.actor.system.characteristics[name];
let showAll = false;
for (const [key, value] of Object.entries(this.actor.system.characteristics)) {
if (!value.show) {
showAll = true;
break;
}
}
const userConfig = await CharacterPrompts.openCharacteristic(game.i18n.localize(`MGT2.Characteristics.${name}.name`), c.show, c.showMax, showAll);
if (userConfig) {
const data = {
system: {
characteristics: {}
}
};
data.system.characteristics[name] = {
show: userConfig.show,
showMax: userConfig.showMax
};
if (userConfig.showAll === true) {
for (const [key, value] of Object.entries(this.actor.system.characteristics)) {
if (key !== name && !value.show) {
data.system.characteristics[key] = { show: true };
}
}
}
this.actor.update(data);
}
}
async _onRoll(event) {
event.preventDefault();
const rollOptions = {
rollTypeName: game.i18n.localize("MGT2.RollPrompt.Roll"),
rollObjectName: "",
characteristics: [{ _id: "", name: "" }],
characteristic: "",
skills: [],
skill: "",
fatigue: this.actor.system.states.fatigue,
encumbrance: this.actor.system.states.encumbrance,
difficulty: null,
damageFormula: null
};
for (const [key, label] of Object.entries(MGT2.Characteristics)) {
const c = this.actor.system.characteristics[key];
if (c.show) {
rollOptions.characteristics.push({ _id: key, name: game.i18n.localize(label) + MGT2Helper.getDisplayDM(c.dm) });
}
}
for (let item of this.actor.items) {
if (item.type === "talent") {
if (item.system.subType === "skill")
rollOptions.skills.push({ _id: item._id, name: item.getRollDisplay() });
}
}
rollOptions.skills.sort(MGT2Helper.compareByName);
rollOptions.skills = [{ _id: "NP", name: game.i18n.localize("MGT2.Items.NotProficient") }].concat(rollOptions.skills);
let itemObj = null;
let isInitiative = false;
const button = event.currentTarget;
if (button.dataset.roll === "initiative") {
rollOptions.rollTypeName = game.i18n.localize("MGT2.RollPrompt.InitiativeRoll");
rollOptions.characteristic = this.actor.system.config.initiative;
isInitiative = true;
} else if (button.dataset.roll === "characteristic") {
rollOptions.characteristic = button.dataset.rollCharacteristic;
rollOptions.rollTypeName = game.i18n.localize("MGT2.RollPrompt.CharacteristicRoll");
rollOptions.rollObjectName = game.i18n.localize(`MGT2.Characteristics.${rollOptions.characteristic}.name`);
} else {
if (button.dataset.roll === "skill") {
rollOptions.skill = button.dataset.rollSkill;
itemObj = this.actor.getEmbeddedDocument("Item", rollOptions.skill);
rollOptions.rollTypeName = game.i18n.localize("MGT2.RollPrompt.SkillRoll");
rollOptions.rollObjectName = itemObj.name;
} else {
if (button.dataset.roll === "psionic") {
rollOptions.rollTypeName = game.i18n.localize("MGT2.RollPrompt.PsionicRoll");
}
}
if (itemObj === null && button.dataset.itemId) {
itemObj = this.actor.getEmbeddedDocument("Item", button.dataset.itemId);
rollOptions.rollObjectName = itemObj.name;
if (itemObj.type === "weapon")
rollOptions.rollTypeName = game.i18n.localize("TYPES.Item.weapon");
else if (itemObj.type === "armor")
rollOptions.rollTypeName = game.i18n.localize("TYPES.Item.armor");
else if (itemObj.type === "computer")
rollOptions.rollTypeName = game.i18n.localize("TYPES.Item.computer");
}
if (button.dataset.roll === "psionic") {
rollOptions.rollObjectName = itemObj.name;
}
if (itemObj.system.hasOwnProperty("damage")) {
rollOptions.damageFormula = itemObj.system.damage;
if (itemObj.type === "disease") {
if (itemObj.system.subTypetype === "disease") {
rollOptions.rollTypeName = game.i18n.localize("DiseaseSubType.disease");
} else if (itemObj.system.subTypetype === "poison") {
rollOptions.rollTypeName = game.i18n.localize("DiseaseSubType.poison");
}
}
}
if (itemObj.system.hasOwnProperty("roll")) {
if (itemObj.system.roll.hasOwnProperty("characteristic") && itemObj.system.roll.characteristic !== "" && itemObj.system.roll.characteristic !== void 0) {
rollOptions.characteristic = itemObj.system.roll.characteristic;
}
if (itemObj.system.roll.hasOwnProperty("skill") && itemObj.system.roll.skill !== "" && itemObj.system.roll.skill !== void 0) {
rollOptions.skill = itemObj.system.roll.skill;
}
if (rollOptions.difficulty === null && itemObj.system.roll.hasOwnProperty("difficulty") && itemObj.system.roll.difficulty !== "" && itemObj.system.roll.difficulty !== void 0) {
rollOptions.difficulty = itemObj.system.roll.difficulty;
}
}
}
const userRollData = await RollPromptHelper.roll(rollOptions);
const rollModifiers = [];
const rollFormulaParts = [];
if (userRollData.diceModifier) {
rollFormulaParts.push("3d6");
rollFormulaParts.push(userRollData.diceModifier);
} else {
rollFormulaParts.push("2d6");
}
if (userRollData.hasOwnProperty("characteristic") && userRollData.characteristic !== "") {
let c = this.actor.system.characteristics[userRollData.characteristic];
let dm = c.dm;
rollFormulaParts.push(MGT2Helper.getFormulaDM(dm));
rollModifiers.push(game.i18n.localize(`MGT2.Characteristics.${userRollData.characteristic}.name`) + MGT2Helper.getDisplayDM(dm));
}
if (userRollData.hasOwnProperty("skill") && userRollData.skill !== "") {
if (userRollData.skill === "NP") {
rollFormulaParts.push("-3");
rollModifiers.push(game.i18n.localize("MGT2.Items.NotProficient"));
} else {
const skillObj = this.actor.getEmbeddedDocument("Item", userRollData.skill);
rollFormulaParts.push(MGT2Helper.getFormulaDM(skillObj.system.level));
rollModifiers.push(skillObj.getRollDisplay());
}
}
if (userRollData.hasOwnProperty("psionic") && userRollData.psionic !== "") {
let psionicObj = this.actor.getEmbeddedDocument("Item", userRollData.psionic);
rollFormulaParts.push(MGT2Helper.getFormulaDM(psionicObj.system.level));
rollModifiers.push(psionicObj.getRollDisplay());
}
if (userRollData.hasOwnProperty("timeframes") && userRollData.timeframes !== "" && userRollData.timeframes !== "Normal") {
rollModifiers.push(game.i18n.localize(`MGT2.Timeframes.${userRollData.timeframes}`));
rollFormulaParts.push(userRollData.timeframes === "Slower" ? "+2" : "-2");
}
if (userRollData.hasOwnProperty("encumbrance") && userRollData.encumbrance === true) {
rollFormulaParts.push("-2");
rollModifiers.push(game.i18n.localize("MGT2.Actor.Encumbrance") + " -2");
}
if (userRollData.hasOwnProperty("fatigue") && userRollData.fatigue === true) {
rollFormulaParts.push("-2");
rollModifiers.push(game.i18n.localize("MGT2.Actor.Fatigue") + " -2");
}
if (userRollData.hasOwnProperty("customDM") && userRollData.customDM !== "") {
let s = userRollData.customDM.trim();
if (/^[0-9]/.test(s))
rollFormulaParts.push("+");
rollFormulaParts.push(s);
}
const rollData = this.actor.getRollData();
const rollFormula = rollFormulaParts.join("");
if (!Roll.validate(rollFormula)) {
ui.notifications.error(game.i18n.localize("MGT2.Errors.InvalidRollFormula"));
return;
}
let roll = await new Roll(rollFormula, rollData).roll({ async: true, rollMode: userRollData.rollMode });
if (isInitiative && this.token && this.token.combatant) {
await this.token.combatant.update({ initiative: roll.total });
}
const chatData = {
user: game.user.id,
speaker: this.actor ? ChatMessage.getSpeaker({ actor: this.actor }) : null,
formula: roll._formula,
//flavor: isPrivate ? null : flavor,
tooltip: await roll.getTooltip(),
total: Math.round(roll.total * 100) / 100,
type: CONST.CHAT_MESSAGE_TYPES.ROLL,
showButtons: true,
showLifeButtons: false,
showRollRequest: false,
rollTypeName: rollOptions.rollTypeName,
rollObjectName: rollOptions.rollObjectName,
rollModifiers,
showRollDamage: rollOptions.damageFormula !== null && rollOptions.damageFormula !== ""
};
const html = await renderTemplate("systems/mgt2/templates/chat/roll.html", chatData);
chatData.content = html;
if (rollOptions.damageFormula !== null && rollOptions.damageFormula !== "") {
chatData.flags = { mgt2: { damage: { formula: rollOptions.damageFormula, rollObjectName: rollOptions.rollObjectName, rollTypeName: rollOptions.rollTypeName } } };
}
return roll.toMessage(chatData);
}
_onItemCreate(ev) {
ev.preventDefault();
const html = $(ev.currentTarget);
const data = {
name: html.data("create-name"),
type: html.data("type-item")
};
if (html.data("subtype")) {
data.system = {
subType: html.data("subtype")
};
}
const cls = getDocumentClass("Item");
return cls.create(data, { parent: this.actor });
}
_onItemEquip(ev) {
ev.preventDefault();
const html = $(ev.currentTarget).parents("[data-item-id]");
const item = duplicate(this.actor.getEmbeddedDocument("Item", html.data("itemId")));
item.system.equipped = !item.system.equipped;
this.actor.updateEmbeddedDocuments("Item", [item]);
}
_onItemStorageIn(ev) {
ev.preventDefault();
const html = $(ev.currentTarget).parents("[data-item-id]");
const item = duplicate(this.actor.getEmbeddedDocument("Item", html.data("itemId")));
if (item.type === "container") {
item.system.onHand = false;
} else {
let container;
const containers = this.actor.getContainers();
if (this.actor.system.containerDropIn == "" || this.actor.system.containerDropIn === null) {
if (containers.length === 0) {
const cls = getDocumentClass("Item");
container = cls.create({ name: "New container", type: "container" }, { parent: this.actor });
} else {
container = containers[0];
}
} else {
container = containers.find((x) => x._id == this.actor.system.containerDropIn);
}
if (container.system.locked) {
if (game.user.isGM) {
item.system.container.id = container._id;
} else {
ui.notifications.error("Objet verrouill\xE9");
}
} else {
item.system.container.id = container._id;
}
}
this.actor.updateEmbeddedDocuments("Item", [item]);
}
_onItemStorageOut(ev) {
ev.preventDefault();
const html = $(ev.currentTarget).parents("[data-item-id]");
const item = duplicate(this.actor.getEmbeddedDocument("Item", html.data("itemId")));
item.system.container.id = "";
this.actor.updateEmbeddedDocuments("Item", [item]);
}
_onSoftwareEject(ev) {
ev.preventDefault();
const html = $(ev.currentTarget).parents("[data-item-id]");
const item = duplicate(this.actor.getEmbeddedDocument("Item", html.data("itemId")));
item.system.software.computerId = "";
this.actor.updateEmbeddedDocuments("Item", [item]);
}
_onContainerCreate(ev) {
ev.preventDefault();
const cls = getDocumentClass("Item");
return cls.create({ name: "New container", type: "container" }, { parent: this.actor });
}
_canDragDrop(selector) {
return this.isEditable;
}
async _onDrop(event) {
event.preventDefault();
event.stopImmediatePropagation();
const dropData = MGT2Helper.getDataFromDropEvent(event);
if (!dropData)
return false;
const sourceItemData = await MGT2Helper.getItemDataFromDropData(dropData);
if (sourceItemData.type !== "contact" && sourceItemData.type !== "talent" && sourceItemData.type !== "armor" && sourceItemData.type !== "weapon" && sourceItemData.type !== "computer" && sourceItemData.type !== "container" && sourceItemData.type !== "species" && sourceItemData.type !== "item" && sourceItemData.type !== "equipment")
return false;
const target = event.target.closest(".table-row");
let targetId = null;
let targetItem = null;
if (target !== null && target !== void 0) {
targetId = target.dataset.itemId;
targetItem = this.actor.getEmbeddedDocument("Item", targetId);
}
let sourceItem = this.actor.getEmbeddedDocument("Item", sourceItemData.id);
if (sourceItem) {
if (targetItem === null || targetItem === void 0)
return false;
sourceItem = duplicate(sourceItem);
if (sourceItem._id === targetId)
return false;
if (targetItem.type === "item" || targetItem.type === "equipment") {
if (targetItem.system.subType === "software") {
sourceItem.system.software.computerId = targetItem.system.software.computerId;
} else {
sourceItem.system.container.id = targetItem.system.container.id;
}
this.actor.updateEmbeddedDocuments("Item", [sourceItem]);
return true;
} else if (targetItem.type === "computer") {
sourceItem.system.software.computerId = targetId;
this.actor.updateEmbeddedDocuments("Item", [sourceItem]);
return true;
} else if (targetItem.type === "container") {
if (targetItem.system.locked && !game.user.isGM)
ui.notifications.error("Verrouill\xE9");
else {
sourceItem.system.container.id = targetId;
this.actor.updateEmbeddedDocuments("Item", [sourceItem]);
return true;
}
}
} else {
let transferData = {};
try {
transferData = sourceItemData.toJSON();
} catch (err) {
transferData = sourceItemData;
}
transferData._id;
delete transferData._id;
delete transferData.id;
const recalcWeight = transferData.system.hasOwnProperty("weight");
if (transferData.system.hasOwnProperty("container"))
transferData.system.container.id = "";
if (transferData.type === "item" && transferData.system.subType === "software")
transferData.system.software.computerId = "";
if (transferData.type === "container")
transferData.onHand = true;
if (transferData.system.hasOwnProperty("equipment"))
transferData.system.equipped = false;
if (targetItem !== null) {
if (transferData.type === "item" && transferData.system.subType === "software") {
if (targetItem.type === "item" && targetItem.system.subType === "software") {
transferData.system.software.computerId = targetItem.system.software.computerId;
} else if (targetItem.type === "computer") {
transferData.system.software.computerId = targetItem._id;
}
} else if (transferData.type === "armor" || transferData.type === "computer" || transferData.type === "equipment" || transferData.type === "item" || transferData.type === "weapon") {
if (targetItem.type === "container") {
if (!targetItem.system.locked || game.user.isGM) {
transferData.system.container.id = targetId;
}
} else {
transferData.system.container.id = targetItem.system.container.id;
}
}
}
(await this.actor.createEmbeddedDocuments("Item", [transferData]))[0];
if (transferData.actor) ;
if (recalcWeight) {
await this.actor.recalculateWeight();
}
}
return true;
}
_getSubmitData(updateData = {}) {
const formData = foundry.utils.expandObject(super._getSubmitData(updateData));
return foundry.utils.flattenObject(formData);
}
}
const preloadHandlebarsTemplates = async function() {
const templatePaths = [
"systems/mgt2/templates/items/parts/sheet-configuration.html",
"systems/mgt2/templates/items/parts/sheet-physical-item.html",
"systems/mgt2/templates/roll-prompt.html",
"systems/mgt2/templates/chat/roll.html",
//"systems/mgt2/templates/chat/roll-characteristic.html",
"systems/mgt2/templates/actors/actor-config-sheet.html",
"systems/mgt2/templates/actors/actor-config-characteristic-sheet.html"
//"systems/mgt2/templates/actors/parts/actor-characteristic.html"
];
return loadTemplates(templatePaths);
};
class ChatHelper {
// _injectContent(message, type, html) {
// _setupCardListeners(message, html);
// }
static setupCardListeners(message, html, messageData) {
if (!message || !html) {
return;
}
html.find('button[data-action="rollDamage"]').click(async (event) => {
await this._processRollDamageButtonEvent(message, event);
});
html.find('button[data-action="damage"]').click(async (event) => {
await this._applyChatCardDamage(message, event);
});
html.find('button[data-action="healing"]').click(async (event) => {
ui.notifications.warn("healing");
});
}
static async _processRollDamageButtonEvent(message, event) {
event.preventDefault();
event.stopPropagation();
let rollFormula = message.flags.mgt2.damage.formula;
let roll = await new Roll(rollFormula, {}).roll({ async: true });
let speaker;
let selectTokens = canvas.tokens.controlled;
if (selectTokens.length > 0) {
speaker = selectTokens[0].actor;
} else {
speaker = game.user.character;
}
let rollTypeName = message.flags.mgt2.damage.rollTypeName ? message.flags.mgt2.damage.rollTypeName + " DAMAGE" : null;
const chatData = {
user: game.user.id,
speaker: ChatMessage.getSpeaker({ actor: speaker }),
formula: roll._formula,
tooltip: await roll.getTooltip(),
total: Math.round(roll.total * 100) / 100,
type: CONST.CHAT_MESSAGE_TYPES.ROLL,
showButtons: true,
hasDamage: true,
rollTypeName,
rollObjectName: message.flags.mgt2.damage.rollObjectName
};
const html = await renderTemplate("systems/mgt2/templates/chat/roll.html", chatData);
chatData.content = html;
return roll.toMessage(chatData);
}
async _processDamageButtonEvent(message, event) {
event.preventDefault();
event.stopPropagation();
await ItemUtility.runItemAction(null, message, ROLL_TYPE.DAMAGE);
}
static _applyChatCardDamage(message, event) {
const roll = message.rolls[0];
return Promise.all(canvas.tokens.controlled.map((t) => {
const a = t.actor;
return a.applyDamage(roll.total);
}));
}
}
const registerSettings = function() {
game.settings.register("mgt2", "theme", {
name: "MGT2.Settings.theme.name",
hint: "MGT2.Settings.theme.hint",
scope: "client",
config: true,
default: "black-and-red",
type: String,
choices: {
"black-and-red": "MGT2.Themes.BlackAndRed",
"mwamba": "MGT2.Themes.Mwamba"
},
requiresReload: true
});
game.settings.register("mgt2", "usePronouns", {
name: "MGT2.Settings.usePronouns.name",
hint: "MGT2.Settings.usePronouns.hint",
default: false,
scope: "world",
type: Boolean,
config: true,
requiresReload: false
});
game.settings.register("mgt2", "useGender", {
name: "MGT2.Settings.useGender.name",
hint: "MGT2.Settings.useGender.hint",
default: false,
scope: "world",
type: Boolean,
config: true,
requiresReload: false
});
game.settings.register("mgt2", "showLife", {
name: "MGT2.Settings.showLife.name",
hint: "MGT2.Settings.showLife.hint",
default: true,
scope: "world",
type: Boolean,
config: true,
requiresReload: false
});
game.settings.register("mgt2", "useWeightMetric", {
name: "MGT2.Settings.useWeightMetric.name",
hint: "MGT2.Settings.useWeightMetric.hint",
default: true,
scope: "world",
type: Boolean,
config: true,
requiresReload: true
});
game.settings.register("mgt2", "useDistanceMetric", {
name: "MGT2.Settings.useDistanceMetric.name",
hint: "MGT2.Settings.useDistanceMetric.hint",
default: true,
scope: "world",
type: Boolean,
config: true,
requiresReload: true
});
};
function registerHandlebarsHelpers() {
Handlebars.registerHelper("showDM", function(dm) {
if (dm === 0)
return "0";
if (dm > 0)
return `+${dm}`;
if (dm < 0)
return `${dm}`;
return "";
});
}
Hooks.once("init", async function() {
CONFIG.MGT2 = MGT2;
CONFIG.Combat.initiative = {
formula: "2d6 + @initiative",
decimals: 2
};
CONFIG.Actor.trackableAttributes = {
character: {
bar: [
"life",
"characteristics.strength",
"characteristics.dexterity",
"characteristics.endurance",
"characteristics.intellect",
"characteristics.education",
"characteristics.social",
"characteristics.morale",
"characteristics.luck",
"characteristics.sanity",
"characteristics.charm",
"characteristics.psionic",
"characteristics.other"
],
value: [
"life.value",
"health.radiations",
"characteristics.strength.value",
"characteristics.dexterity.value",
"characteristics.endurance.value",
"characteristics.intellect.value",
"characteristics.education.value",
"characteristics.social.value",
"characteristics.morale.value",
"characteristics.luck.value",
"characteristics.sanity.value",
"characteristics.charm.value",
"characteristics.psionic.value",
"characteristics.other.value"
]
}
};
game.mgt2 = {
TravellerActor,
TravellerItem
};
registerHandlebarsHelpers();
registerSettings();
CONFIG.Combatant.documentClass = MGT2Combatant;
CONFIG.Actor.documentClass = TravellerActor;
CONFIG.Item.documentClass = TravellerItem;
Actors.unregisterSheet("core", ActorSheet);
Actors.registerSheet("mgt2", TravellerActorSheet, { types: ["character"], makeDefault: true, label: "Traveller Sheet" });
Items.unregisterSheet("core", ItemSheet);
Items.registerSheet("mgt2", TravellerItemSheet, { makeDefault: true });
Object.assign(CONFIG.Actor.dataModels, {
"character": CharacterData
});
Object.assign(CONFIG.Item.dataModels, {
"item": ItemData,
"equipment": EquipmentData,
"disease": DiseaseData,
"career": CareerData,
"talent": TalentData,
"contact": ContactData,
"weapon": WeaponData,
"computer": ComputerData,
"armor": ArmorData,
"container": ItemContainerData,
"species": SpeciesData
});
Hooks.on("renderChatMessage", (message, html, messageData) => {
ChatHelper.setupCardListeners(message, html, messageData);
});
await preloadHandlebarsTemplates();
});
export { MGT2 };
//# sourceMappingURL=mgt2.bundle.js.map
Reference in New Issue View Git Blame Copy Permalink