mirror of
https://github.com/Foundryborne/daggerheart.git
synced 2026-01-11 19:25:21 +01:00
349 lines
No EOL
13 KiB
JavaScript
349 lines
No EOL
13 KiB
JavaScript
import DamageSelectionDialog from "../applications/damageSelectionDialog.mjs";
|
|
import NpcRollSelectionDialog from "../applications/npcRollSelectionDialog.mjs";
|
|
import RollSelectionDialog from "../applications/rollSelectionDialog.mjs";
|
|
import { GMUpdateEvent, socketEvent } from "../helpers/socket.mjs";
|
|
|
|
export default class DhpActor extends Actor {
|
|
_preCreate(data, changes, user){
|
|
if(data.type === 'pc'){
|
|
data.prototypeToken = { actorLink: true, disposition: 1, sight: { enabled: true } };
|
|
}
|
|
|
|
super._preCreate(data, changes, user);
|
|
}
|
|
|
|
prepareData(){
|
|
super.prepareData();
|
|
}
|
|
|
|
async _preUpdate(changed, options, user) {
|
|
//Level Down
|
|
if(changed.system?.levelData?.changedLevel && this.system.levelData.currentLevel > changed.system.levelData.changedLevel){
|
|
changed.system.levelData.currentLevel = changed.system.levelData.changedLevel;
|
|
changed.system.levelData.levelups = Object.keys(this.system.levelData.levelups).reduce((acc, x) => {
|
|
if(x > changed.system.levelData.currentLevel){
|
|
acc[`-=${x}`] = null;
|
|
}
|
|
|
|
return acc;
|
|
}, {});
|
|
|
|
changed.system.attributes = Object.keys(this.system.attributes).reduce((acc, key) => {
|
|
acc[key] = { levelMarks: this.system.attributes[key].levelMarks.filter(x => x <= changed.system.levelData.currentLevel) };
|
|
|
|
return acc;
|
|
}, {});
|
|
|
|
changed.system.experiences = this.system.experiences.filter(x => x.level <= changed.system.levelData.currentLevel);
|
|
|
|
if(this.system.multiclass && this.system.multiclass.system.multiclass > changed.system.levelData.changedLevel){
|
|
const multiclassFeatures = this.items.filter(x => x.system.multiclass);
|
|
for(var feature of multiclassFeatures){
|
|
await feature.delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
super._preUpdate(changed, options, user);
|
|
}
|
|
|
|
async diceRoll(modifier, shiftKey) {
|
|
if(this.type === 'pc'){
|
|
return await this.dualityRoll(modifier, shiftKey);
|
|
}
|
|
else {
|
|
return await this.npcRoll(modifier, shiftKey);
|
|
}
|
|
}
|
|
|
|
async npcRoll(modifier, shiftKey) {
|
|
let nrDice = 1;
|
|
let advantage = null;
|
|
|
|
const modifiers = [
|
|
{
|
|
value: Number.parseInt(modifier.value),
|
|
label: modifier.value >= 0 ? `+${modifier.value}` : `-${modifier.value}`,
|
|
title: modifier.title,
|
|
}
|
|
];
|
|
if(!shiftKey) {
|
|
const dialogClosed = new Promise((resolve, _) => {
|
|
new NpcRollSelectionDialog(this.system.experiences, resolve).render(true);
|
|
});
|
|
const result = await dialogClosed;
|
|
|
|
nrDice = result.nrDice;
|
|
advantage = result.advantage;
|
|
result.experiences.forEach(x => modifiers.push({ value: x.value, label: x.value >= 0 ? `+${x.value}` : `-${x.value}`, title: x.description }))
|
|
}
|
|
|
|
const roll = new Roll(`${nrDice}d20${advantage === true ? 'kh' : advantage === false ? 'kl': ''} ${modifiers.map(x => `+ ${x.value}`).join(' ')}`);
|
|
let rollResult = await roll.evaluate();
|
|
const diceResults = rollResult.dice.flatMap(x => x.results.flatMap(result => ({ value: result.result })));
|
|
|
|
return { roll, diceResults: diceResults, modifiers: modifiers };
|
|
}
|
|
|
|
async dualityRoll(modifier, shiftKey, bonusDamage=[]){
|
|
let hopeDice = 'd12', fearDice = 'd12', advantageDice = null, disadvantageDice = null, bonusDamageString = "";
|
|
const modifiers = [
|
|
{
|
|
value: Number.parseInt(modifier.value),
|
|
label: modifier.value >= 0 ? `+${modifier.value}` : `-${modifier.value}`,
|
|
title: modifier.title,
|
|
}
|
|
];
|
|
if(!shiftKey) {
|
|
const dialogClosed = new Promise((resolve, _) => {
|
|
new RollSelectionDialog(this.system.experiences, bonusDamage, this.system.resources.hope.value, resolve).render(true);
|
|
});
|
|
const result = await dialogClosed;
|
|
hopeDice = result.hope, fearDice = result.fear, advantageDice = result.advantage, disadvantageDice = result.disadvantage;
|
|
result.experiences.forEach(x => modifiers.push({ value: x.value, label: x.value >= 0 ? `+${x.value}` : `-${x.value}`, title: x.description }))
|
|
bonusDamageString = result.bonusDamage;
|
|
|
|
const automateHope = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Automation.Hope);
|
|
if(automateHope && result.hopeUsed){
|
|
await this.update({ "system.resources.hope.value": this.system.resources.hope.value - result.hopeUsed });
|
|
}
|
|
}
|
|
|
|
const roll = new Roll(`1${hopeDice} + 1${fearDice}${advantageDice ? ` + 1${advantageDice}` : disadvantageDice ? ` - 1${disadvantageDice}` : ''} ${modifiers.map(x => `+ ${x.value}`).join(' ')}`);
|
|
let rollResult = await roll.evaluate();
|
|
rollResult.dice[0].options.appearance = {
|
|
colorset:"inspired",
|
|
foreground: "#FFFFFF",
|
|
background: "#008080",
|
|
outline: "#000000",
|
|
edge: "#806400",
|
|
texture: "bloodmoon",
|
|
material: "metal",
|
|
font: "Arial Black",
|
|
system: "standard"
|
|
};
|
|
if(advantageDice || disadvantageDice){
|
|
rollResult.dice[1].options.appearance = {
|
|
colorset:"inspired",
|
|
foreground: disadvantageDice ? "#b30000" : "#FFFFFF",
|
|
background: "#008080",
|
|
outline: disadvantageDice ? "#000000" : "#000000",
|
|
edge: "#806400",
|
|
texture: "bloodmoon",
|
|
material: "metal",
|
|
font: "Arial Black",
|
|
system: "standard"
|
|
};
|
|
rollResult.dice[2].options.appearance = {
|
|
colorset:"bloodmoon",
|
|
foreground: "#000000",
|
|
background: "#430070",
|
|
outline: "#b30000",
|
|
edge: "#000000",
|
|
texture: "bloodmoon",
|
|
material: "metal",
|
|
font: "Arial Black",
|
|
system: "standard"
|
|
};
|
|
}
|
|
else {
|
|
rollResult.dice[1].options.appearance = {
|
|
colorset:"bloodmoon",
|
|
foreground: "#000000",
|
|
background: "#430070",
|
|
outline: "#b30000",
|
|
edge: "#000000",
|
|
texture: "bloodmoon",
|
|
material: "metal",
|
|
font: "Arial Black",
|
|
system: "standard"
|
|
};
|
|
}
|
|
|
|
const hope = rollResult.dice[0].results[0].result;
|
|
const advantage = advantageDice ? rollResult.dice[1].results[0].result : null;
|
|
const disadvantage = disadvantageDice ? rollResult.dice[1].results[0].result : null;
|
|
const fear = advantage || disadvantage ? rollResult.dice[2].results[0].result : rollResult.dice[1].results[0].result;
|
|
|
|
if(disadvantage){
|
|
rollResult = {...rollResult, total: rollResult.total - Math.max(hope, disadvantage) };
|
|
}
|
|
if(advantage){
|
|
rollResult = {...rollResult, total: 'Select Hope Die' };
|
|
}
|
|
|
|
const automateHope = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Automation.Hope);
|
|
if (automateHope && hope > fear){
|
|
await this.update({ "system.resources.hope.value": Math.min(this.system.resources.hope.value+1, this.system.resources.hope.max) });
|
|
}
|
|
|
|
if(automateHope && hope === fear){
|
|
await this.update({ "system.resources": {
|
|
"hope.value": Math.min(this.system.resources.hope.value+1, this.system.resources.hope.max),
|
|
"stress.value": Math.max(this.system.resources.stress.value-1, 0),
|
|
}});
|
|
}
|
|
|
|
return { roll, rollResult, hope: { dice: hopeDice, value: hope }, fear: { dice: fearDice, value: fear }, advantage: { dice: advantageDice, value: advantage }, disadvantage: { dice: disadvantageDice, value: disadvantage }, modifiers: modifiers, bonusDamageString };
|
|
}
|
|
|
|
async damageRoll(damage, shiftKey){
|
|
let rollString = damage.value;
|
|
let bonusDamage = damage.bonusDamage?.filter(x => x.initiallySelected) ?? [];
|
|
if(!shiftKey) {
|
|
const dialogClosed = new Promise((resolve, _) => {
|
|
new DamageSelectionDialog(rollString, bonusDamage, this.system.resources.hope.value, resolve).render(true);
|
|
});
|
|
const result = await dialogClosed;
|
|
bonusDamage = result.bonusDamage;
|
|
rollString = result.rollString;
|
|
|
|
const automateHope = await game.settings.get(SYSTEM.id, SYSTEM.SETTINGS.gameSettings.Automation.Hope);
|
|
if(automateHope && result.hopeUsed){
|
|
await this.update({ "system.resources.hope.value": this.system.resources.hope.value - result.hopeUsed });
|
|
}
|
|
}
|
|
|
|
const roll = new Roll(rollString);
|
|
let rollResult = await roll.evaluate();
|
|
|
|
const dice = [];
|
|
const modifiers = [];
|
|
for(var i = 0; i < rollResult.terms.length; i++){
|
|
const term = rollResult.terms[i];
|
|
if(term.faces){
|
|
dice.push({type: `d${term.faces}`, value: term.total});
|
|
}
|
|
else if (term.operator){
|
|
|
|
}
|
|
else if(term.number){
|
|
const operator = i === 0 ? '' : rollResult.terms[i-1].operator;
|
|
modifiers.push(`${operator}${term.number}`);
|
|
}
|
|
}
|
|
|
|
const cls = getDocumentClass("ChatMessage");
|
|
const msg = new cls({
|
|
user: game.user.id,
|
|
content: await renderTemplate("systems/daggerheart/templates/chat/damage-roll.hbs", {
|
|
roll: rollString,
|
|
total: rollResult.total,
|
|
dice: dice,
|
|
modifiers: modifiers
|
|
}),
|
|
rolls: [roll]
|
|
});
|
|
|
|
cls.create(msg.toObject());
|
|
}
|
|
|
|
async takeDamage(damage, type){
|
|
const hpDamage =
|
|
damage >= this.system.damageThresholds.severe ? 3 :
|
|
damage >= this.system.damageThresholds.major ? 2 :
|
|
damage >= this.system.damageThresholds.minor ? 1 :
|
|
0;
|
|
|
|
const update = { "system.resources.health.value": Math.min(this.system.resources.health.value+hpDamage, this.system.resources.health.max) };
|
|
|
|
if(game.user.isGM){
|
|
await this.update(update);
|
|
} else {
|
|
await game.socket.emit(`system.${SYSTEM.id}`, {
|
|
action: socketEvent.GMUpdate,
|
|
data: {
|
|
action: GMUpdateEvent.UpdateDocument,
|
|
uuid: this.uuid,
|
|
update: update,
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
async takeHealing(healing, type) {
|
|
let update = { };
|
|
switch(type){
|
|
case SYSTEM.GENERAL.healingTypes.health.id:
|
|
update = { "system.resources.health.value": Math.max(this.system.resources.health.value - healing, 0) };
|
|
break;
|
|
case SYSTEM.GENERAL.healingTypes.stress.id:
|
|
update = { "system.resources.stress.value": Math.max(this.system.resources.stress.value - healing, 0) };
|
|
break;
|
|
}
|
|
|
|
if(game.user.isGM){
|
|
await this.update(update);
|
|
} else {
|
|
await game.socket.emit(`system.${SYSTEM.id}`, {
|
|
action: socketEvent.GMUpdate,
|
|
data: {
|
|
action: GMUpdateEvent.UpdateDocument,
|
|
uuid: this.uuid,
|
|
update: update,
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
async emulateItemDrop(data) {
|
|
const event = new DragEvent("drop", { altKey: game.keyboard.isModifierActive("Alt") });
|
|
return this.sheet._onDropItem(event, { data: data });
|
|
}
|
|
|
|
//Move to action-scope?
|
|
async useAction(action) {
|
|
const userTargets = Array.from(game.user.targets);
|
|
const otherTarget = action.target.type ===SYSTEM.ACTIONS.targetTypes.other.id;
|
|
if(otherTarget && userTargets.length === 0) {
|
|
ui.notifications.error(game.i18n.localize("DAGGERHEART.Notification.Error.ActionRequiresTarget"));
|
|
return;
|
|
}
|
|
|
|
if(action.cost.type != null && action.cost.value != null){
|
|
if (this.system.resources[action.cost.type].value < action.cost.value-1) {
|
|
ui.notifications.error(game.i18n.localize(`Insufficient ${action.cost.type} to use this ability`));
|
|
return;
|
|
}
|
|
}
|
|
|
|
// const targets = otherTarget ? userTargets : [game.user.character];
|
|
if(action.damage.type){
|
|
let roll = { formula: action.damage.value, result: action.damage.value };
|
|
if(Number.isNaN(Number.parseInt(action.damage.value))){
|
|
roll = await new Roll(`1${action.damage.value}`).evaluate();
|
|
}
|
|
|
|
const cls = getDocumentClass("ChatMessage");
|
|
const msg = new cls({
|
|
user: game.user.id,
|
|
content: await renderTemplate("systems/daggerheart/templates/chat/damage-roll.hbs", {
|
|
roll: roll.formula,
|
|
total: roll.result,
|
|
type: action.damage.type,
|
|
}),
|
|
});
|
|
|
|
cls.create(msg.toObject());
|
|
}
|
|
|
|
if(action.healing.type){
|
|
let roll = { formula: action.healing.value, result: action.healing.value };
|
|
if(Number.isNaN(Number.parseInt(action.healing.value))){
|
|
roll = await new Roll(`1${action.healing.value}`).evaluate();
|
|
}
|
|
|
|
const cls = getDocumentClass("ChatMessage");
|
|
const msg = new cls({
|
|
user: game.user.id,
|
|
content: await renderTemplate("systems/daggerheart/templates/chat/healing-roll.hbs", {
|
|
roll: roll.formula,
|
|
total: roll.result,
|
|
type: action.healing.type,
|
|
}),
|
|
});
|
|
|
|
cls.create(msg.toObject());
|
|
}
|
|
}
|
|
} |