Initiali import
This commit is contained in:
354
modules/imperium5-actor-sheet.js
Normal file
354
modules/imperium5-actor-sheet.js
Normal file
@@ -0,0 +1,354 @@
|
||||
/**
|
||||
* Extend the basic ActorSheet with some very simple modifications
|
||||
* @extends {ActorSheet}
|
||||
*/
|
||||
|
||||
import { Imperium5Utility } from "./imperium5-utility.js";
|
||||
import { Imperium5RollDialog } from "./imperium5-roll-dialog.js";
|
||||
|
||||
/* -------------------------------------------- */
|
||||
export class PegasusActorSheet extends ActorSheet {
|
||||
|
||||
/** @override */
|
||||
static get defaultOptions() {
|
||||
|
||||
return mergeObject(super.defaultOptions, {
|
||||
classes: ["fvtt-pegasus-rpg", "sheet", "actor"],
|
||||
template: "systems/fvtt-pegasus-rpg/templates/actor-sheet.html",
|
||||
width: 920,
|
||||
height: 720,
|
||||
tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "combat" }],
|
||||
dragDrop: [{ dragSelector: ".item-list .item", dropSelector: null }],
|
||||
editScore: true
|
||||
});
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async getData() {
|
||||
const objectData = PegasusUtility.data(this.object);
|
||||
|
||||
let actorData = duplicate(PegasusUtility.templateData(this.object));
|
||||
|
||||
let formData = {
|
||||
title: this.title,
|
||||
id: objectData.id,
|
||||
type: objectData.type,
|
||||
img: objectData.img,
|
||||
name: objectData.name,
|
||||
editable: this.isEditable,
|
||||
cssClass: this.isEditable ? "editable" : "locked",
|
||||
data: actorData,
|
||||
effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
|
||||
limited: this.object.limited,
|
||||
specs: this.actor.getSpecs( ),
|
||||
optionsDiceList: PegasusUtility.getOptionsDiceList(),
|
||||
optionsLevel: PegasusUtility.getOptionsLevel(),
|
||||
weapons: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getWeapons()) ),
|
||||
armors: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getArmors())),
|
||||
shields: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getShields()) ),
|
||||
equipments: this.actor.checkAndPrepareEquipments(duplicate(this.actor.getEquipmentsOnly()) ),
|
||||
perks: duplicate(this.actor.getPerks()),
|
||||
abilities: duplicate(this.actor.getAbilities()),
|
||||
activePerks: duplicate(this.actor.getActivePerks()),
|
||||
powers: duplicate(this.actor.getPowers()),
|
||||
subActors: duplicate(this.actor.getSubActors()),
|
||||
race: duplicate(this.actor.getRace()),
|
||||
role: duplicate(this.actor.getRole()),
|
||||
effects: duplicate(this.actor.getEffects()),
|
||||
moneys: duplicate(this.actor.getMoneys()),
|
||||
encCapacity: this.actor.getEncumbranceCapacity(),
|
||||
containersTree: this.actor.containersTree,
|
||||
encCurrent: this.actor.encCurrent,
|
||||
encHindrance: this.actor.encHindrance,
|
||||
options: this.options,
|
||||
owner: this.document.isOwner,
|
||||
editScore: this.options.editScore,
|
||||
isGM: game.user.isGM
|
||||
}
|
||||
this.formData = formData;
|
||||
|
||||
console.log("PC : ", formData, this.object);
|
||||
return formData;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async openGenericRoll() {
|
||||
let rollData = PegasusUtility.getBasicRollData()
|
||||
rollData.alias = "Dice Pool Roll",
|
||||
rollData.mode = "generic"
|
||||
rollData.title = `Dice Pool Roll`
|
||||
rollData.img = "icons/dice/d12black.svg"
|
||||
|
||||
let rollDialog = await PegasusRollDialog.create( this.actor, rollData);
|
||||
rollDialog.render( true );
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async rollIDR( itemId, diceValue) {
|
||||
let item = this.actor.data.items.get( itemId) ?? {name: "Unknown"}
|
||||
let myRoll = new Roll(diceValue+"x").roll({ async: false })
|
||||
await PegasusUtility.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"))
|
||||
let chatData = {
|
||||
user: game.user.id,
|
||||
rollMode: game.settings.get("core", "rollMode"),
|
||||
whisper: [game.user.id].concat(ChatMessage.getWhisperRecipients('GM')),
|
||||
content: `${this.actor.name} has roll IDR for ${item.name} : ${myRoll.total}`
|
||||
}
|
||||
ChatMessage.create(chatData)
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/** @override */
|
||||
activateListeners(html) {
|
||||
super.activateListeners(html);
|
||||
|
||||
// Everything below here is only needed if the sheet is editable
|
||||
if (!this.options.editable) return;
|
||||
|
||||
html.bind("keydown", function(e) { // Ignore Enter in actores sheet
|
||||
if (e.keyCode === 13) return false;
|
||||
});
|
||||
|
||||
// Update Inventory Item
|
||||
html.find('.item-edit').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let itemId = li.data("item-id");
|
||||
const item = this.actor.items.get( itemId );
|
||||
item.sheet.render(true);
|
||||
});
|
||||
// Delete Inventory Item
|
||||
html.find('.item-delete').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
PegasusUtility.confirmDelete(this, li);
|
||||
});
|
||||
|
||||
html.find('.spec-group-activate').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let itemId = li.data("item-id");
|
||||
this.actor.specPowerActivate( itemId)
|
||||
});
|
||||
html.find('.spec-group-deactivate').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let itemId = li.data("item-id");
|
||||
this.actor.specPowerDeactivate( itemId)
|
||||
});
|
||||
|
||||
html.find('.equip-activate').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item")
|
||||
let itemId = li.data("item-id")
|
||||
this.actor.equipActivate( itemId)
|
||||
});
|
||||
html.find('.equip-deactivate').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item")
|
||||
let itemId = li.data("item-id")
|
||||
this.actor.equipDeactivate( itemId)
|
||||
});
|
||||
|
||||
html.find('.effect-used').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let itemId = li.data("item-id");
|
||||
this.actor.perkEffectUsed( itemId)
|
||||
});
|
||||
|
||||
html.find('.perk-status').change(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let itemId = li.data("item-id");
|
||||
this.actor.updatePerkStatus( itemId, ev.currentTarget.value)
|
||||
});
|
||||
|
||||
html.find('.power-cost-spent').change(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let itemId = li.data("item-id");
|
||||
this.actor.updatePowerSpentCost( itemId, ev.currentTarget.value)
|
||||
});
|
||||
|
||||
html.find('.power-dmg-roll').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item")
|
||||
let itemId = li.data("item-id")
|
||||
this.actor.powerDmgRoll( itemId )
|
||||
})
|
||||
|
||||
html.find('.perk-used').change(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item")
|
||||
let itemId = li.data("item-id")
|
||||
let index = Number($(ev.currentTarget).data("use-index") )
|
||||
this.actor.updatePerkUsed( itemId, index, ev.currentTarget.checked )
|
||||
});
|
||||
|
||||
html.find('.subactor-edit').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let actorId = li.data("actor-id");
|
||||
let actor = game.actors.get( actorId );
|
||||
actor.sheet.render(true);
|
||||
});
|
||||
|
||||
html.find('.subactor-delete').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let actorId = li.data("actor-id");
|
||||
this.actor.delSubActor(actorId);
|
||||
});
|
||||
|
||||
html.find('.quantity-minus').click(event => {
|
||||
const li = $(event.currentTarget).parents(".item");
|
||||
this.actor.incDecQuantity( li.data("item-id"), -1 );
|
||||
} );
|
||||
html.find('.quantity-plus').click(event => {
|
||||
const li = $(event.currentTarget).parents(".item");
|
||||
this.actor.incDecQuantity( li.data("item-id"), +1 );
|
||||
} );
|
||||
|
||||
html.find('.ammo-minus').click(event => {
|
||||
const li = $(event.currentTarget).parents(".item")
|
||||
this.actor.incDecAmmo( li.data("item-id"), -1 );
|
||||
} );
|
||||
html.find('.ammo-plus').click(event => {
|
||||
const li = $(event.currentTarget).parents(".item")
|
||||
this.actor.incDecAmmo( li.data("item-id"), +1 )
|
||||
} );
|
||||
|
||||
html.find('.momentum-minus').click(event => {
|
||||
this.actor.modifyMomentum( -1 )
|
||||
} )
|
||||
html.find('.momentum-plus').click(event => {
|
||||
this.actor.modifyMomentum( 1 )
|
||||
} )
|
||||
|
||||
html.find('.unarmed-attack').click((event) => {
|
||||
this.actor.rollUnarmedAttack();
|
||||
});
|
||||
html.find('.generic-pool-roll').click((event) => {
|
||||
this.openGenericRoll()
|
||||
} );
|
||||
html.find('.attack-melee').click((event) => {
|
||||
this.actor.rollPool( 'com');
|
||||
});
|
||||
html.find('.attack-ranged').click((event) => {
|
||||
this.actor.rollPool( 'agi');
|
||||
});
|
||||
html.find('.defense-roll').click((event) => {
|
||||
this.actor.rollPool( 'def', true);
|
||||
});
|
||||
html.find('.damage-melee').click((event) => {
|
||||
this.actor.rollPool( 'str');
|
||||
});
|
||||
html.find('.damage-ranged').click((event) => {
|
||||
this.actor.rollPool( 'per');
|
||||
});
|
||||
html.find('.damage-resistance').click((event) => {
|
||||
this.actor.rollPool( 'phy');
|
||||
});
|
||||
|
||||
html.find('.roll-stat').click((event) => {
|
||||
const statId = $(event.currentTarget).data("stat-key");
|
||||
this.actor.rollStat(statId);
|
||||
});
|
||||
html.find('.roll-mr').click((event) => {
|
||||
this.actor.rollMR();
|
||||
});
|
||||
html.find('.roll-idr').click((event) => {
|
||||
const diceValue = $(event.currentTarget).data("dice-value")
|
||||
const li = $(event.currentTarget).parents(".item")
|
||||
this.rollIDR( li.data("item-id"), diceValue)
|
||||
})
|
||||
|
||||
html.find('.roll-spec').click((event) => {
|
||||
const li = $(event.currentTarget).parents(".item");
|
||||
const specId = li.data("item-id");
|
||||
this.actor.rollSpec(specId);
|
||||
});
|
||||
html.find('.power-roll').click((event) => {
|
||||
const li = $(event.currentTarget).parents(".item");
|
||||
const powerId = li.data("item-id");
|
||||
this.actor.rollPower(powerId);
|
||||
});
|
||||
html.find('.weapon-roll').click((event) => {
|
||||
const li = $(event.currentTarget).parents(".item");
|
||||
const weaponId = li.data("item-id");
|
||||
this.actor.rollWeapon(weaponId);
|
||||
});
|
||||
html.find('.armor-roll').click((event) => {
|
||||
const li = $(event.currentTarget).parents(".item");
|
||||
const armorId = li.data("item-id");
|
||||
this.actor.rollArmor(armorId);
|
||||
});
|
||||
|
||||
html.find('.weapon-damage-roll').click((event) => {
|
||||
const li = $(event.currentTarget).parents(".item");
|
||||
const weaponId = li.data("item-id");
|
||||
this.actor.rollWeapon(weaponId, true);
|
||||
});
|
||||
|
||||
html.find('.weapon-damage').click((event) => {
|
||||
const li = $(event.currentTarget).parents(".item");
|
||||
const weapon = this.actor.getOwnedItem(li.data("item-id"));
|
||||
this.actor.rollDamage(weapon, 'damage');
|
||||
});
|
||||
|
||||
html.find('.lock-unlock-sheet').click((event) => {
|
||||
this.options.editScore = !this.options.editScore;
|
||||
this.render(true);
|
||||
});
|
||||
html.find('.item-link a').click((event) => {
|
||||
const itemId = $(event.currentTarget).data("item-id");
|
||||
const item = this.actor.getOwnedItem(itemId);
|
||||
item.sheet.render(true);
|
||||
});
|
||||
html.find('.item-equip').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
this.actor.equipItem( li.data("item-id") );
|
||||
this.render(true);
|
||||
});
|
||||
html.find('.power-activate').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
this.actor.activatePower( li.data("item-id") );
|
||||
this.render(true);
|
||||
});
|
||||
|
||||
html.find('.change-worstfear').change(ev => {
|
||||
this.actor.manageWorstFear( ev.currentTarget.checked )
|
||||
});
|
||||
html.find('.change-desires').change(ev => {
|
||||
this.actor.manageDesires( ev.currentTarget.checked )
|
||||
});
|
||||
|
||||
html.find('.update-field').change(ev => {
|
||||
const fieldName = $(ev.currentTarget).data("field-name");
|
||||
let value = Number(ev.currentTarget.value);
|
||||
this.actor.update( { [`${fieldName}`]: value } );
|
||||
});
|
||||
html.find('.perk-active').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
this.actor.activatePerk( li.data("item-id") );
|
||||
this.render(true);
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/** @override */
|
||||
setPosition(options = {}) {
|
||||
const position = super.setPosition(options);
|
||||
const sheetBody = this.element.find(".sheet-body");
|
||||
const bodyHeight = position.height - 192;
|
||||
sheetBody.css("height", bodyHeight);
|
||||
return position;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async _onDropItem(event, dragData) {
|
||||
console.log(">>>>>> DROPPED!!!!")
|
||||
let item = await PegasusUtility.searchItem( dragData)
|
||||
if (item == undefined) {
|
||||
item = this.actor.items.get( dragData.data._id )
|
||||
}
|
||||
this.actor.preprocessItem( event, item, true )
|
||||
super._onDropItem(event, dragData)
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/** @override */
|
||||
_updateObject(event, formData) {
|
||||
// Update the Actor
|
||||
return this.object.update(formData);
|
||||
}
|
||||
}
|
||||
1303
modules/imperium5-actor.js
Normal file
1303
modules/imperium5-actor.js
Normal file
File diff suppressed because it is too large
Load Diff
38
modules/imperium5-combat.js
Normal file
38
modules/imperium5-combat.js
Normal file
@@ -0,0 +1,38 @@
|
||||
import { Imperium5Utility } from "./imperium5pegasus-utility.js";
|
||||
|
||||
/* -------------------------------------------- */
|
||||
export class PegasusCombat extends Combat {
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async rollInitiative(ids, formula = undefined, messageOptions = {} ) {
|
||||
ids = typeof ids === "string" ? [ids] : ids;
|
||||
for (let cId = 0; cId < ids.length; cId++) {
|
||||
const c = this.combatants.get(ids[cId]);
|
||||
let id = c._id || c.id;
|
||||
let initBonus = c.actor ? c.actor.getInitiativeScore( this.id, id ) : -1;
|
||||
await this.updateEmbeddedDocuments("Combatant", [ { _id: id, initiative: initBonus } ]);
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
_onUpdate(changed, options, userId) {
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async checkTurnPosition() {
|
||||
while (game.combat.turn > 0) {
|
||||
await game.combat.previousTurn()
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async decInitBy10( combatantId, value) {
|
||||
const combatant = game.combat.combatants.get(combatantId)
|
||||
let initValue = combatant.initiative + value
|
||||
await game.combat.setInitiative(combatantId, initValue)
|
||||
setTimeout( this.checkTurnPosition, 400) // The setInitiative is no more blocking for unknown reason
|
||||
}
|
||||
|
||||
}
|
||||
123
modules/imperium5-commands.js
Normal file
123
modules/imperium5-commands.js
Normal file
@@ -0,0 +1,123 @@
|
||||
/* -------------------------------------------- */
|
||||
|
||||
import { Imperium5Utility } from "./imperium5-utility.js";
|
||||
import { Imperium5RollDialog } from "./imperium5-roll-dialog.js";
|
||||
|
||||
/* -------------------------------------------- */
|
||||
export class PegasusCommands {
|
||||
|
||||
static init() {
|
||||
if (!game.system.pegasus.commands) {
|
||||
const pegasusCommands = new PegasusCommands();
|
||||
pegasusCommands.registerCommand({ path: ["/char"], func: (content, msg, params) => pegasusCommands.createChar(msg), descr: "Create a new character" });
|
||||
pegasusCommands.registerCommand({ path: ["/pool"], func: (content, msg, params) => pegasusCommands.poolRoll(msg), descr: "Generic Roll Window" });
|
||||
game.system.pegasus.commands = pegasusCommands;
|
||||
}
|
||||
}
|
||||
constructor() {
|
||||
this.commandsTable = {};
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
registerCommand(command) {
|
||||
this._addCommand(this.commandsTable, command.path, '', command);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
_addCommand(targetTable, path, fullPath, command) {
|
||||
if (!this._validateCommand(targetTable, path, command)) {
|
||||
return;
|
||||
}
|
||||
const term = path[0];
|
||||
fullPath = fullPath + term + ' '
|
||||
if (path.length == 1) {
|
||||
command.descr = `<strong>${fullPath}</strong>: ${command.descr}`;
|
||||
targetTable[term] = command;
|
||||
}
|
||||
else {
|
||||
if (!targetTable[term]) {
|
||||
targetTable[term] = { subTable: {} };
|
||||
}
|
||||
this._addCommand(targetTable[term].subTable, path.slice(1), fullPath, command)
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
_validateCommand(targetTable, path, command) {
|
||||
if (path.length > 0 && path[0] && command.descr && (path.length != 1 || targetTable[path[0]] == undefined)) {
|
||||
return true;
|
||||
}
|
||||
console.warn("pegasusCommands._validateCommand failed ", targetTable, path, command);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/* Manage chat commands */
|
||||
processChatCommand(commandLine, content = '', msg = {}) {
|
||||
// Setup new message's visibility
|
||||
let rollMode = game.settings.get("core", "rollMode");
|
||||
if (["gmroll", "blindroll"].includes(rollMode)) msg["whisper"] = ChatMessage.getWhisperRecipients("GM");
|
||||
if (rollMode === "blindroll") msg["blind"] = true;
|
||||
msg["type"] = 0;
|
||||
|
||||
let command = commandLine[0].toLowerCase();
|
||||
let params = commandLine.slice(1);
|
||||
|
||||
return this.process(command, params, content, msg);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
process(command, params, content, msg) {
|
||||
return this._processCommand(this.commandsTable, command, params, content, msg);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
_processCommand(commandsTable, name, params, content = '', msg = {}, path = "") {
|
||||
console.log("===> Processing command")
|
||||
let command = commandsTable[name];
|
||||
path = path + name + " ";
|
||||
if (command && command.subTable) {
|
||||
if (params[0]) {
|
||||
return this._processCommand(command.subTable, params[0], params.slice(1), content, msg, path)
|
||||
}
|
||||
else {
|
||||
this.help(msg, command.subTable);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (command && command.func) {
|
||||
const result = command.func(content, msg, params);
|
||||
if (result == false) {
|
||||
RdDCommands._chatAnswer(msg, command.descr);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async createChar(msg) {
|
||||
game.system.pegasus.creator = new PegasusActorCreate();
|
||||
game.system.pegasus.creator.start();
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static _chatAnswer(msg, content) {
|
||||
msg.whisper = [game.user.id];
|
||||
msg.content = content;
|
||||
ChatMessage.create(msg);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async poolRoll( msg) {
|
||||
let rollData = PegasusUtility.getBasicRollData()
|
||||
rollData.alias = "Dice Pool Roll",
|
||||
rollData.mode = "generic"
|
||||
rollData.title = `Dice Pool Roll`;
|
||||
|
||||
let rollDialog = await PegasusRollDialog.create( this, rollData);
|
||||
rollDialog.render( true );
|
||||
}
|
||||
|
||||
}
|
||||
509
modules/imperium5-item-sheet.js
Normal file
509
modules/imperium5-item-sheet.js
Normal file
@@ -0,0 +1,509 @@
|
||||
import { Imperium5Utility } from "./imperium5-utility.js";
|
||||
|
||||
/**
|
||||
* Extend the basic ItemSheet with some very simple modifications
|
||||
* @extends {ItemSheet}
|
||||
*/
|
||||
export class PegasusItemSheet extends ItemSheet {
|
||||
|
||||
/** @override */
|
||||
static get defaultOptions() {
|
||||
|
||||
return mergeObject(super.defaultOptions, {
|
||||
classes: ["fvtt-pegasus-rpg", "sheet", "item"],
|
||||
template: "systems/fvtt-pegasus-rpg/templates/item-sheet.html",
|
||||
dragDrop: [{ dragSelector: null, dropSelector: null }],
|
||||
width: 620,
|
||||
height: 550,
|
||||
tabs: [{navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "description"}]
|
||||
});
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
_getHeaderButtons() {
|
||||
let buttons = super._getHeaderButtons();
|
||||
// Add "Post to chat" button
|
||||
// We previously restricted this to GM and editable items only. If you ever find this comment because it broke something: eh, sorry!
|
||||
buttons.unshift(
|
||||
{
|
||||
class: "post",
|
||||
icon: "fas fa-comment",
|
||||
onclick: ev => { }
|
||||
})
|
||||
return buttons
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/** @override */
|
||||
setPosition(options = {}) {
|
||||
const position = super.setPosition(options);
|
||||
const sheetBody = this.element.find(".sheet-body");
|
||||
const bodyHeight = position.height - 192;
|
||||
sheetBody.css("height", bodyHeight);
|
||||
if (this.item.type.includes('weapon')) {
|
||||
position.width = 640;
|
||||
}
|
||||
return position;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async getData() {
|
||||
const objectData = PegasusUtility.data(this.object);
|
||||
|
||||
let itemData = foundry.utils.deepClone(PegasusUtility.templateData(this.object));
|
||||
let formData = {
|
||||
title: this.title,
|
||||
id: this.id,
|
||||
type: objectData.type,
|
||||
img: objectData.img,
|
||||
name: objectData.name,
|
||||
editable: this.isEditable,
|
||||
cssClass: this.isEditable ? "editable" : "locked",
|
||||
optionsDiceList: PegasusUtility.getOptionsDiceList(),
|
||||
optionsStatusList: PegasusUtility.getOptionsStatusList(),
|
||||
data: itemData,
|
||||
limited: this.object.limited,
|
||||
options: this.options,
|
||||
owner: this.document.isOwner,
|
||||
mr: (this.object.type == 'specialisation'),
|
||||
isGM: game.user.isGM
|
||||
}
|
||||
|
||||
this.options.editable = !(this.object.data.origin == "embeddedItem");
|
||||
console.log("ITEM DATA", formData, this);
|
||||
return formData;
|
||||
}
|
||||
|
||||
|
||||
/* -------------------------------------------- */
|
||||
_getHeaderButtons() {
|
||||
let buttons = super._getHeaderButtons();
|
||||
buttons.unshift({
|
||||
class: "post",
|
||||
icon: "fas fa-comment",
|
||||
onclick: ev => this.postItem()
|
||||
});
|
||||
return buttons
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
postItem() {
|
||||
let chatData = duplicate(PegasusUtility.data(this.item));
|
||||
if (this.actor) {
|
||||
chatData.actor = { id: this.actor.id };
|
||||
}
|
||||
// Don't post any image for the item (which would leave a large gap) if the default image is used
|
||||
if (chatData.img.includes("/blank.png")) {
|
||||
chatData.img = null;
|
||||
}
|
||||
// JSON object for easy creation
|
||||
chatData.jsondata = JSON.stringify(
|
||||
{
|
||||
compendium: "postedItem",
|
||||
payload: chatData,
|
||||
});
|
||||
|
||||
renderTemplate('systems/fvtt-pegasus-rpg/templates/post-item.html', chatData).then(html => {
|
||||
let chatOptions = PegasusUtility.chatDataSetup(html);
|
||||
ChatMessage.create(chatOptions)
|
||||
});
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async viewSubitem(ev) {
|
||||
let field = $(ev.currentTarget).data('type');
|
||||
let idx = Number($(ev.currentTarget).data('index'));
|
||||
let itemData = this.object.data.data[field][idx];
|
||||
if (itemData.name != 'None') {
|
||||
let spec = await Item.create(itemData, { temporary: true });
|
||||
spec.data.origin = "embeddedItem";
|
||||
new PegasusItemSheet(spec).render(true);
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async deleteSubitem(ev) {
|
||||
let field = $(ev.currentTarget).data('type');
|
||||
let idx = Number($(ev.currentTarget).data('index'));
|
||||
let oldArray = this.object.data.data[field];
|
||||
let itemData = this.object.data.data[field][idx];
|
||||
if (itemData.name != 'None') {
|
||||
let newArray = [];
|
||||
for (var i = 0; i < oldArray.length; i++) {
|
||||
if (i != idx) {
|
||||
newArray.push(oldArray[i]);
|
||||
}
|
||||
}
|
||||
this.object.update({ [`data.${field}`]: newArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async manageSpec() {
|
||||
let itemData = this.object.data.data.specialisation[0];
|
||||
if (itemData.name != 'None') {
|
||||
let spec = await Item.create(itemData, { temporary: true });
|
||||
spec.data.origin = "embeddedItem";
|
||||
new PegasusItemSheet(spec).render(true);
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/** @override */
|
||||
activateListeners(html) {
|
||||
super.activateListeners(html);
|
||||
|
||||
// Everything below here is only needed if the sheet is editable
|
||||
if (!this.options.editable) return;
|
||||
|
||||
|
||||
// Update Inventory Item
|
||||
html.find('.item-edit').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
const item = this.object.options.actor.getOwnedItem(li.data("item-id"));
|
||||
item.sheet.render(true);
|
||||
});
|
||||
|
||||
html.find('.delete-spec').click(ev => {
|
||||
this.object.update({ "data.specialisation": [{ name: 'None' }] });
|
||||
});
|
||||
|
||||
html.find('.delete-subitem').click(ev => {
|
||||
this.deleteSubitem(ev);
|
||||
});
|
||||
|
||||
html.find('.stat-choice-flag').click(ev => {
|
||||
let idx = $(ev.currentTarget).data("stat-idx");
|
||||
let array = duplicate(this.object.data.data.statincreasechoice);
|
||||
array[Number(idx)].flag = !array[Number(idx)].flag;
|
||||
this.object.update({ "data.statincreasechoice": array });
|
||||
});
|
||||
|
||||
// Update Inventory Item
|
||||
html.find('.item-delete').click(ev => {
|
||||
const li = $(ev.currentTarget).parents(".item");
|
||||
let itemId = li.data("item-id");
|
||||
let itemType = li.data("item-type");
|
||||
});
|
||||
|
||||
html.find('.view-subitem').click(ev => {
|
||||
this.viewSubitem(ev);
|
||||
});
|
||||
|
||||
html.find('.view-spec').click(ev => {
|
||||
this.manageSpec();
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addAbility(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
console.log("ABB", event, item, dataItem)
|
||||
if (event.toElement.className == 'drop-abilities') {
|
||||
let abilityArray = duplicate(this.object.data.data.abilities);
|
||||
abilityArray.push(newItem);
|
||||
await this.object.update({ 'data.abilities': abilityArray });
|
||||
}
|
||||
if (event.toElement.className == 'drop-optionnal-abilities') {
|
||||
let abilityArray = duplicate(this.object.data.data.optionnalabilities);
|
||||
abilityArray.push(newItem);
|
||||
await this.object.update({ 'data.optionnalabilities': abilityArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addRacePerk(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
if (event.toElement.className == 'drop-race-perk') {
|
||||
let perkArray = duplicate(this.object.data.data.perks);
|
||||
perkArray.push(newItem);
|
||||
await this.object.update({ 'data.perks': perkArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addSpecialisation(item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
let specArray = [newItem];
|
||||
await this.object.update({ 'data.specialisation': specArray });
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addRoleSpecialisation(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
console.log("Add spec", event, newItem);
|
||||
if (event.toElement.className == 'drop-spec1') {
|
||||
let specArray = duplicate(this.object.data.data.specialisationsplus1);
|
||||
specArray.push(newItem);
|
||||
await this.object.update({ 'data.specialisationsplus1': specArray });
|
||||
}
|
||||
if (event.toElement.className == 'drop-spec2') {
|
||||
let specArray = duplicate(this.object.data.data.specincrease);
|
||||
specArray.push(newItem);
|
||||
await this.object.update({ 'data.specincrease': specArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addRolePerk(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
console.log("Add spec", event, newItem);
|
||||
if (event.toElement.className == 'drop-perk2') {
|
||||
let perkArray = duplicate(this.object.data.data.perks);
|
||||
perkArray.push(newItem);
|
||||
await this.object.update({ 'data.perks': perkArray });
|
||||
}
|
||||
if (event.toElement.className == 'drop-specialperk1') {
|
||||
let perkArray = duplicate(this.object.data.data.specialperk);
|
||||
perkArray.push(newItem);
|
||||
await this.object.update({ 'data.specialperk': perkArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addPower(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
if (event.toElement.className == 'drop-spec-power') {
|
||||
let powArray = duplicate(this.object.data.data.powers);
|
||||
powArray.push(newItem);
|
||||
await this.object.update({ 'data.powers': powArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addAbilityPower(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
if (event.toElement.className == 'drop-ability-power') {
|
||||
let powArray = duplicate(this.object.data.data.powersgained);
|
||||
powArray.push(newItem);
|
||||
await this.object.update({ 'data.powersgained': powArray });
|
||||
}
|
||||
}
|
||||
/* -------------------------------------------- */
|
||||
async addAbilityEffect(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
if (event.toElement.className == 'drop-ability-effect') {
|
||||
let powArray = duplicate(this.object.data.data.effectsgained);
|
||||
powArray.push(newItem);
|
||||
await this.object.update({ 'data.effectsgained': powArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addAbilitySpec(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
if (event.toElement.className == 'drop-ability-spec') {
|
||||
let powArray = duplicate(this.object.data.data.specialisations);
|
||||
powArray.push(newItem);
|
||||
await this.object.update({ 'data.specialisations': powArray });
|
||||
}
|
||||
}
|
||||
/* -------------------------------------------- */
|
||||
async addAbilityWeaponArmor(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
newItem._id = randomID(dataItem.id.length);
|
||||
if (event.toElement.className == 'drop-ability-weapon') {
|
||||
let weaponArray = duplicate(this.object.data.data.attackgained);
|
||||
weaponArray.push(newItem);
|
||||
await this.object.update({ 'data.attackgained': weaponArray });
|
||||
}
|
||||
if (event.toElement.className == 'drop-ability-armor') {
|
||||
let armorArray = duplicate(this.object.data.data.armorgained);
|
||||
armorArray.push(newItem);
|
||||
await this.object.update({ 'data.armorgained': armorArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addPerkSpecialisation(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
if (event.toElement.className == 'drop-spec-perk') {
|
||||
//console.log("PER SPEC", event)
|
||||
let key = event.toElement.dataset["key"];
|
||||
if (key == 'affectedspec') {
|
||||
await this.object.update({ 'data.features.affectedspec.value': newItem.name });
|
||||
} else {
|
||||
await this.object.update({ 'data.features.gainspecdice.value': newItem.name });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addPerkEffect(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data)
|
||||
if (event.toElement.className == 'drop-perk-effect') {
|
||||
let effectArray = duplicate(this.object.data.data.effectsgained)
|
||||
effectArray.push(newItem)
|
||||
await this.object.update({ 'data.effectsgained': effectArray })
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addEffectPower(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data)
|
||||
if (event.toElement.className == 'drop-power-effect') {
|
||||
let effectArray = duplicate(this.object.data.data.effectsgained)
|
||||
effectArray.push(newItem);
|
||||
await this.object.update({ 'data.effectsgained': effectArray })
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addEffectSpec(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
if (event.toElement.className == 'drop-effect-spec') {
|
||||
let specArray = duplicate(this.object.data.data.recoveryrollspec);
|
||||
specArray.push(newItem);
|
||||
await this.object.update({ 'data.recoveryrollspec': specArray });
|
||||
}
|
||||
if (event.toElement.className == 'drop-effect-specaffected') {
|
||||
let specArray = duplicate(this.object.data.data.specaffected);
|
||||
specArray.push(newItem);
|
||||
await this.object.update({ 'data.specaffected': specArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async addEffectItem(event, item, dataItem) {
|
||||
let newItem = duplicate(item.data);
|
||||
if (event.toElement.className == 'drop-equipment-effect') {
|
||||
let effectArray = duplicate(this.object.data.data.effects);
|
||||
effectArray.push(newItem);
|
||||
await this.object.update({ 'data.effects': effectArray });
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
async _onDrop(event) {
|
||||
|
||||
if (this.object.type == 'weapon' || this.object.type == 'armor' || this.object.type == 'shield'
|
||||
|| this.object.type == 'equipment') {
|
||||
let data = event.dataTransfer.getData('text/plain');
|
||||
if (data) {
|
||||
let dataItem = JSON.parse(data);
|
||||
let item = await PegasusUtility.searchItem(dataItem);
|
||||
if (item.data.type == 'effect') {
|
||||
return this.addEffectItem(event, item, dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this.object.type == 'power') {
|
||||
let data = event.dataTransfer.getData('text/plain');
|
||||
if (data) {
|
||||
let dataItem = JSON.parse(data);
|
||||
let item = await PegasusUtility.searchItem(dataItem);
|
||||
if (item.data.type == 'effect') {
|
||||
return this.addEffectPower(event, item, dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this.object.type == 'effect') {
|
||||
let data = event.dataTransfer.getData('text/plain');
|
||||
if (data) {
|
||||
let dataItem = JSON.parse(data);
|
||||
let item = await PegasusUtility.searchItem(dataItem);
|
||||
if (item.data.type == 'specialisation') {
|
||||
return this.addEffectSpec(event, item, dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this.object.type == 'race') {
|
||||
let data = event.dataTransfer.getData('text/plain');
|
||||
if (data) {
|
||||
let dataItem = JSON.parse(data);
|
||||
let item = await PegasusUtility.searchItem(dataItem);
|
||||
if (item.data.type == 'ability') {
|
||||
return this.addAbility(event, item, dataItem);
|
||||
}
|
||||
if (item.data.type == 'perk') {
|
||||
return this.addRacePerk(event, item, dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this.object.type == 'perk') {
|
||||
let data = event.dataTransfer.getData('text/plain')
|
||||
if (data) {
|
||||
let dataItem = JSON.parse(data);
|
||||
let item = await PegasusUtility.searchItem(dataItem)
|
||||
if (item.data.type == 'specialisation') {
|
||||
return this.addPerkSpecialisation(event, item, dataItem)
|
||||
}
|
||||
if (item.data.type == 'effect') {
|
||||
return this.addPerkEffect(event, item, dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this.object.type == 'specialisation') {
|
||||
let data = event.dataTransfer.getData('text/plain');
|
||||
if (data) {
|
||||
let dataItem = JSON.parse(data);
|
||||
let item = await PegasusUtility.searchItem(dataItem);
|
||||
if (item.data.type == 'power') {
|
||||
return this.addPower(event, item, dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (this.object.type == 'ability') {
|
||||
let data = event.dataTransfer.getData('text/plain');
|
||||
if (data) {
|
||||
let dataItem = JSON.parse(data);
|
||||
let item = await PegasusUtility.searchItem(dataItem);
|
||||
if (item.data.type == 'effect') {
|
||||
return this.addAbilityEffect(event, item, dataItem);
|
||||
}
|
||||
if (item.data.type == 'power') {
|
||||
return this.addAbilityPower(event, item, dataItem);
|
||||
}
|
||||
if (item.data.type == 'specialisation') {
|
||||
return this.addAbilitySpec(event, item, dataItem);
|
||||
}
|
||||
if (item.data.type == 'weapon' || item.data.type == 'armor') {
|
||||
return this.addAbilityWeaponArmor(event, item, dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this.object.type == 'role') {
|
||||
let data = event.dataTransfer.getData('text/plain');
|
||||
if (data) {
|
||||
let dataItem = JSON.parse(data);
|
||||
let item = await PegasusUtility.searchItem(dataItem);
|
||||
if (item.data.type == 'specialisation') {
|
||||
return this.addRoleSpecialisation(event, item, dataItem);
|
||||
}
|
||||
if (item.data.type == 'perk') {
|
||||
return this.addRolePerk(event, item, dataItem);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ui.notifications.warn("This item can not be dropped over another item");
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
get template() {
|
||||
let type = this.item.type;
|
||||
return `systems/fvtt-pegasus-rpg/templates/item-${type}-sheet.html`;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/** @override */
|
||||
_updateObject(event, formData) {
|
||||
return this.object.update(formData);
|
||||
}
|
||||
}
|
||||
32
modules/imperium5-item.js
Normal file
32
modules/imperium5-item.js
Normal file
@@ -0,0 +1,32 @@
|
||||
|
||||
export const defaultItemImg = {
|
||||
specialisation: "systems/fvtt-pegasus-rpg/images/icons/icon_spec.webp",
|
||||
perk: "systems/fvtt-pegasus-rpg/images/icons/icon_perk.webp",
|
||||
ability: "systems/fvtt-pegasus-rpg/images/icons/icon_raceability.webp",
|
||||
armor: "systems/fvtt-pegasus-rpg/images/icons/icon_armour.webp",
|
||||
weapon: "systems/fvtt-pegasus-rpg/images/icons/icon_weapon.webp",
|
||||
equipment: "systems/fvtt-pegasus-rpg/images/icons/icon_equipment.webp",
|
||||
effect: "systems/fvtt-pegasus-rpg/images/icons/icon_effect.webp",
|
||||
race: "systems/fvtt-pegasus-rpg/images/icons/icon_race.webp",
|
||||
power: "systems/fvtt-pegasus-rpg/images/icons/icon_power.webp",
|
||||
armour: "systems/fvtt-pegasus-rpg/images/icons/icon_armour.webp",
|
||||
equipment: "systems/fvtt-pegasus-rpg/images/icons/icon_equipment.webp",
|
||||
weapon: "systems/fvtt-pegasus-rpg/images/icons/icon_meleeweapon.webp",
|
||||
shield: "systems/fvtt-pegasus-rpg/images/icons/icon_shield.webp",
|
||||
money: "systems/fvtt-pegasus-rpg/images/icons/icon_money.webp",
|
||||
}
|
||||
|
||||
/**
|
||||
* Extend the basic ItemSheet with some very simple modifications
|
||||
* @extends {ItemSheet}
|
||||
*/
|
||||
export class PegasusItem extends Item {
|
||||
|
||||
constructor(data, context) {
|
||||
if (!data.img) {
|
||||
data.img = defaultItemImg[data.type];
|
||||
}
|
||||
super(data, context);
|
||||
}
|
||||
|
||||
}
|
||||
128
modules/imperium5-main.js
Normal file
128
modules/imperium5-main.js
Normal file
@@ -0,0 +1,128 @@
|
||||
/**
|
||||
* imperium5 system
|
||||
* Author: Uberwald
|
||||
* Software License: Prop
|
||||
*/
|
||||
|
||||
/* -------------------------------------------- */
|
||||
|
||||
/* -------------------------------------------- */
|
||||
// Import Modules
|
||||
import { Imperium5Actor } from "./imperium5-actor.js";
|
||||
import { Imperium5ItemSheet } from "./imperium5-item-sheet.js";
|
||||
import { Imperium5ActorSheet } from "./imperium5-actor-sheet.js";
|
||||
import { Imperium5Utility } from "./imperium5-utility.js";
|
||||
import { Imperium5Combat } from "./imperium5-combat.js";
|
||||
import { Imperium5Item } from "./imperium5-item.js";
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/* Foundry VTT Initialization */
|
||||
/* -------------------------------------------- */
|
||||
|
||||
/************************************************************************************/
|
||||
Hooks.once("init", async function () {
|
||||
console.log(`Initializing Pegasus RPG`);
|
||||
|
||||
/* -------------------------------------------- */
|
||||
// preload handlebars templates
|
||||
PegasusUtility.preloadHandlebarsTemplates();
|
||||
|
||||
/* -------------------------------------------- */
|
||||
game.settings.register("fvtt-pegasus-rpg", "dice-max-level", {
|
||||
name: "Maximum level value for dices lists",
|
||||
hint: "Se the maximum level value for dices lists",
|
||||
scope: "world",
|
||||
config: true,
|
||||
default: 20,
|
||||
type: Number
|
||||
});
|
||||
|
||||
/* -------------------------------------------- */
|
||||
// Set an initiative formula for the system
|
||||
CONFIG.Combat.initiative = {
|
||||
formula: "1d6",
|
||||
decimals: 1
|
||||
};
|
||||
|
||||
/* -------------------------------------------- */
|
||||
game.socket.on("system.fvtt-pegasus-rpg", data => {
|
||||
PegasusUtility.onSocketMesssage(data)
|
||||
});
|
||||
|
||||
/* -------------------------------------------- */
|
||||
// Define custom Entity classes
|
||||
CONFIG.Combat.documentClass = PegasusCombat
|
||||
CONFIG.Actor.documentClass = PegasusActor
|
||||
CONFIG.Item.documentClass = PegasusItem
|
||||
//CONFIG.Token.objectClass = PegasusToken
|
||||
game.system.pegasus = { };
|
||||
|
||||
/* -------------------------------------------- */
|
||||
// Register sheet application classes
|
||||
Actors.unregisterSheet("core", ActorSheet);
|
||||
Actors.registerSheet("fvtt-pegasus", PegasusActorSheet, { types: ["character"], makeDefault: true });
|
||||
Actors.registerSheet("fvtt-pegasus", PegasusNPCSheet, { types: ["npc"], makeDefault: false });
|
||||
|
||||
Items.unregisterSheet("core", ItemSheet);
|
||||
Items.registerSheet("fvtt-pegasus", PegasusItemSheet, { makeDefault: true });
|
||||
|
||||
PegasusUtility.init();
|
||||
|
||||
});
|
||||
|
||||
/* -------------------------------------------- */
|
||||
function welcomeMessage() {
|
||||
ChatMessage.create({
|
||||
user: game.user.id,
|
||||
whisper: [game.user.id],
|
||||
content: `<div id="welcome-message-pegasus"><span class="rdd-roll-part">
|
||||
<strong>Welcome to the Pegasus Engine CORE RPG.</strong>
|
||||
<br>Created by GMD Online
|
||||
<p>The Pegasus Engine is a available for free on our website. It is also available as a PDF and in Print format at an affordable price.</p>
|
||||
<p>This project has been made possible thanks to all the Official GMD Members and Patreon Members that have supported me and as a result made it possible to supply this interface for free.</p>
|
||||
<p>In return I have made available a fully detailed Compendium for FREE for all members, which can be obtained from the Members page on my website.</p>
|
||||
<P>You too can become a supporter for future projects and enjoy amazing rewards.
|
||||
<BR>Sign up Here : https://www.gmdonline.co.uk/gmdmemberspage/</p>
|
||||
<p>GMD Online, GMD CORE RPG logo are © 2018 CORE Worlds and Game Rules © 2001. Interface © 2021 All rights reserved.</p>
|
||||
<p>Enjoy and become the hero you were born to be!</p>
|
||||
` });
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/* Foundry VTT Initialization */
|
||||
/* -------------------------------------------- */
|
||||
Hooks.once("ready", function () {
|
||||
|
||||
PegasusUtility.ready();
|
||||
// User warning
|
||||
if (!game.user.isGM && game.user.character == undefined) {
|
||||
ui.notifications.info("Warning ! No character linked to your user !");
|
||||
ChatMessage.create({
|
||||
content: "<b>WARNING</b> The player " + game.user.name + " is not linked to a character !",
|
||||
user: game.user._id
|
||||
});
|
||||
}
|
||||
|
||||
// CSS patch for v9
|
||||
if (game.version) {
|
||||
let sidebar = document.getElementById("sidebar");
|
||||
sidebar.style.width = "min-content";
|
||||
}
|
||||
|
||||
welcomeMessage();
|
||||
});
|
||||
|
||||
/* -------------------------------------------- */
|
||||
/* Foundry VTT Initialization */
|
||||
/* -------------------------------------------- */
|
||||
Hooks.on("chatMessage", (html, content, msg) => {
|
||||
if (content[0] == '/') {
|
||||
let regExp = /(\S+)/g;
|
||||
let commands = content.match(regExp);
|
||||
if (game.system.pegasus.commands.processChatCommand(commands, content, msg)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
});
|
||||
|
||||
239
modules/imperium5-roll-dialog.js
Normal file
239
modules/imperium5-roll-dialog.js
Normal file
@@ -0,0 +1,239 @@
|
||||
import { Imperium5Utility } from "./imperium5-utility.js";
|
||||
|
||||
export class PegasusRollDialog extends Dialog {
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async create(actor, rollData ) {
|
||||
|
||||
let options = { classes: ["PegasusDialog"], width: 620, height: 380, 'z-index': 99999 };
|
||||
let html = await renderTemplate('systems/fvtt-pegasus-rpg/templates/roll-dialog-generic.html', rollData);
|
||||
|
||||
return new PegasusRollDialog(actor, rollData, html, options );
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
constructor(actor, rollData, html, options, close = undefined) {
|
||||
let conf = {
|
||||
title: (rollData.mode == "skill") ? "Skill" : "Roll",
|
||||
content: html,
|
||||
buttons: {
|
||||
roll: {
|
||||
icon: '<i class="fas fa-check"></i>',
|
||||
label: "Roll !",
|
||||
callback: () => { this.roll() }
|
||||
},
|
||||
cancel: {
|
||||
icon: '<i class="fas fa-times"></i>',
|
||||
label: "Cancel",
|
||||
callback: () => { this.close() }
|
||||
} },
|
||||
close: close
|
||||
}
|
||||
|
||||
super(conf, options);
|
||||
|
||||
this.actor = actor;
|
||||
this.rollData = rollData;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
roll () {
|
||||
PegasusUtility.rollPegasus( this.rollData )
|
||||
}
|
||||
|
||||
|
||||
/* -------------------------------------------- */
|
||||
manageEffects( effectIdx, toggled) {
|
||||
let effect = this.rollData.effectsList[effectIdx]
|
||||
if (effect) {
|
||||
effect.applied = toggled
|
||||
|
||||
let level, genre, idVal
|
||||
if (effect.type == 'hindrance' ) {
|
||||
level = effect.value
|
||||
genre = 'positive'
|
||||
idVal = "#hindranceDicesLevel"
|
||||
}
|
||||
if (effect.type == 'effect' ) {
|
||||
let effectData = effect.effect
|
||||
level = effectData.data.effectlevel
|
||||
genre = effectData.data.genre
|
||||
effectData.data.isUsed = toggled
|
||||
if (effectData.data.bonusdice) {
|
||||
idVal = "#bonusDicesLevel"
|
||||
}
|
||||
if (effectData.data.reducedicevalue || effectData.data.statdice) {
|
||||
idVal = "#statDicesLevel"
|
||||
}
|
||||
if (effectData.data.otherdice) {
|
||||
idVal = "#otherDicesLevel"
|
||||
}
|
||||
if (effectData.data.hindrance) {
|
||||
idVal = "#hindranceDicesLevel"
|
||||
genre = 'positive' // Dynamic fix
|
||||
}
|
||||
}
|
||||
// Now process the dice level update
|
||||
let newLevel = Number($(idVal).val())
|
||||
console.log("Ongoing", newLevel, toggled, idVal )
|
||||
if (toggled) {
|
||||
if ( genre == 'positive') {
|
||||
newLevel += Number(level)
|
||||
}else {
|
||||
newLevel -= Number(level)
|
||||
}
|
||||
}else {
|
||||
if ( genre == 'positive') {
|
||||
newLevel -= Number(level)
|
||||
}else {
|
||||
newLevel += Number(level)
|
||||
}
|
||||
}
|
||||
newLevel = (newLevel<0) ? 0 : newLevel
|
||||
$(idVal).val(newLevel)
|
||||
}
|
||||
//console.log("Effect", effect, toggled)
|
||||
this.rollData.statDicesLevel = Number($('#statDicesLevel').val())
|
||||
this.rollData.specDicesLevel = Number($('#specDicesLevel').val())
|
||||
this.rollData.bonusDicesLevel = Number($('#bonusDicesLevel').val())
|
||||
this.rollData.hindranceDicesLevel = Number($('#hindranceDicesLevel').val())
|
||||
this.rollData.otherDicesLevel = Number($('#otherDicesLevel').val())
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
manageArmors( armorIdx, toggled) {
|
||||
let armor = this.rollData.armorsList[armorIdx]
|
||||
if (armor) {
|
||||
armor.applied = toggled
|
||||
if (armor.type == 'other' ) {
|
||||
if (toggled) {
|
||||
this.rollData.otherDicesLevel += Number(armor.value)
|
||||
} else {
|
||||
this.rollData.otherDicesLevel -= Number(armor.value)
|
||||
this.rollData.otherDicesLevel = (this.rollData.otherDicesLevel<0) ? 0 : this.rollData.otherDicesLevel
|
||||
}
|
||||
$("#otherDicesLevel").val(this.rollData.otherDicesLevel)
|
||||
}
|
||||
}
|
||||
console.log("Armor", armorIdx, toggled)
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
manageWeapons( weaponIdx, toggled) {
|
||||
let weapon = this.rollData.weaponsList[weaponIdx]
|
||||
if (weapon) {
|
||||
if (toggled) {
|
||||
this.rollData.weaponName = weapon.weapon.name
|
||||
} else {
|
||||
this.rollData.weaponName = undefined
|
||||
}
|
||||
weapon.applied = toggled
|
||||
if (weapon.type == 'damage' || weapon.type == 'enhanced' ) {
|
||||
if (toggled) {
|
||||
this.rollData.otherDicesLevel += Number(weapon.value)
|
||||
} else {
|
||||
this.rollData.weaponName = undefined
|
||||
this.rollData.otherDicesLevel -= Number(weapon.value)
|
||||
this.rollData.otherDicesLevel = (this.rollData.otherDicesLevel<0) ? 0 : this.rollData.otherDicesLevel
|
||||
}
|
||||
$("#otherDicesLevel").val(this.rollData.otherDicesLevel)
|
||||
}
|
||||
}
|
||||
console.log("Weapon", weaponIdx, toggled, this.rollData.otherDicesLevel, weapon)
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
manageEquip( equipIdx, toggled) {
|
||||
let equip = this.rollData.equipmentsList[equipIdx]
|
||||
if (equip) {
|
||||
equip.applied = toggled
|
||||
let idVal = "#otherDicesLevel" // Default
|
||||
if (equip.equip.data.bonusdice) {
|
||||
idVal = "#bonusDicesLevel"
|
||||
}
|
||||
if (equip.equip.data.statdice) {
|
||||
idVal = "#statDicesLevel"
|
||||
}
|
||||
if (equip.equip.data.otherdice) {
|
||||
idVal = "#otherDicesLevel"
|
||||
}
|
||||
let newLevel = Number($(idVal).val())
|
||||
if (toggled) {
|
||||
newLevel += Number(equip.value)
|
||||
} else {
|
||||
newLevel -= Number(equip.value)
|
||||
}
|
||||
newLevel = (newLevel <0) ? 0 : newLevel
|
||||
$(idVal).val(newLevel)
|
||||
// Then refresh
|
||||
this.rollData.statDicesLevel = Number($('#statDicesLevel').val())
|
||||
this.rollData.specDicesLevel = Number($('#specDicesLevel').val())
|
||||
this.rollData.bonusDicesLevel = Number($('#bonusDicesLevel').val())
|
||||
this.rollData.hindranceDicesLevel = Number($('#hindranceDicesLevel').val())
|
||||
this.rollData.otherDicesLevel = Number($('#otherDicesLevel').val())
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
activateListeners(html) {
|
||||
super.activateListeners(html);
|
||||
|
||||
var dialog = this;
|
||||
function onLoad() {
|
||||
}
|
||||
$(function () { onLoad(); });
|
||||
|
||||
html.find('#specList').change(async (event) => {
|
||||
this.rollData.selectedSpec = event.currentTarget.value
|
||||
let spec = this.rollData.specList.find(item => item._id == this.rollData.selectedSpec)
|
||||
if ( spec) {
|
||||
this.rollData.specDiceLevel = spec.data.level
|
||||
this.rollData.specName = spec.name
|
||||
$('#specDicesLevel').val(this.rollData.specDiceLevel)
|
||||
} else {
|
||||
this.rollData.specName = undefined
|
||||
$('#specDicesLevel').val(0)
|
||||
}
|
||||
const content = await renderTemplate("systems/fvtt-pegasus-rpg/templates/roll-dialog-generic.html", this.rollData)
|
||||
this.data.content = content
|
||||
this.render(true)
|
||||
});
|
||||
html.find('#statDicesLevel').change((event) => {
|
||||
this.rollData.statDicesLevel = Number(event.currentTarget.value)
|
||||
});
|
||||
html.find('#specDicesLevel').change((event) => {
|
||||
this.rollData.specDicesLevel = Number(event.currentTarget.value)
|
||||
});
|
||||
html.find('#bonusDicesLevel').change((event) => {
|
||||
this.rollData.bonusDicesLevel = Number(event.currentTarget.value)
|
||||
});
|
||||
html.find('#hindranceDicesLevel').change((event) => {
|
||||
this.rollData.hindranceDicesLevel = Number(event.currentTarget.value)
|
||||
});
|
||||
html.find('#otherDicesLevel').change((event) => {
|
||||
this.rollData.otherDicesLevel = Number(event.currentTarget.value)
|
||||
});
|
||||
html.find('.effect-clicked').change((event) => {
|
||||
let toggled = event.currentTarget.checked
|
||||
let effectIdx = $(event.currentTarget).data("effect-idx")
|
||||
this.manageEffects( effectIdx, toggled)
|
||||
});
|
||||
html.find('.armor-clicked').change((event) => {
|
||||
let toggled = event.currentTarget.checked
|
||||
let armorIdx = $(event.currentTarget).data("armor-idx")
|
||||
this.manageArmors( armorIdx, toggled)
|
||||
});
|
||||
html.find('.weapon-clicked').change((event) => {
|
||||
let toggled = event.currentTarget.checked
|
||||
let weaponIdx = $(event.currentTarget).data("weapon-idx")
|
||||
this.manageWeapons( weaponIdx, toggled)
|
||||
});
|
||||
html.find('.equip-clicked').change((event) => {
|
||||
let toggled = event.currentTarget.checked
|
||||
let equipIdx = $(event.currentTarget).data("equip-idx")
|
||||
this.manageEquip( equipIdx, toggled)
|
||||
});
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
741
modules/imperium5-utility.js
Normal file
741
modules/imperium5-utility.js
Normal file
@@ -0,0 +1,741 @@
|
||||
/* -------------------------------------------- */
|
||||
import { Imperium5Combat } from "./imperium5-combat.js";
|
||||
import { Imperium5Commands } from "./imperium5-commands.js";
|
||||
|
||||
/* -------------------------------------------- */
|
||||
const __level2Dice = ["d0", "d4", "d6", "d8", "d10", "d12"];
|
||||
const __name2DiceValue = { "0": 0, "d0": 0, "d4": 4, "d6": 6, "d8": 8, "d10": 10, "d12": 12 }
|
||||
|
||||
/* -------------------------------------------- */
|
||||
export class Imperium5Utility {
|
||||
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async init() {
|
||||
Hooks.on('renderChatLog', (log, html, data) => PegasusUtility.chatListeners(html));
|
||||
Hooks.on("getCombatTrackerEntryContext", (html, options) => {
|
||||
PegasusUtility.pushInitiativeOptions(html, options);
|
||||
});
|
||||
Hooks.on("dropCanvasData", (canvas, data) => {
|
||||
PegasusUtility.dropItemOnToken(canvas, data)
|
||||
});
|
||||
|
||||
this.rollDataStore = {}
|
||||
this.defenderStore = {}
|
||||
this.diceList = [];
|
||||
this.diceFoundryList = [];
|
||||
this.optionsDiceList = "";
|
||||
this.buildDiceLists();
|
||||
PegasusCommands.init();
|
||||
|
||||
Handlebars.registerHelper('count', function (list) {
|
||||
return list.length;
|
||||
})
|
||||
Handlebars.registerHelper('includes', function (array, val) {
|
||||
return array.includes(val);
|
||||
})
|
||||
Handlebars.registerHelper('upper', function (text) {
|
||||
return text.toUpperCase();
|
||||
})
|
||||
Handlebars.registerHelper('lower', function (text) {
|
||||
return text.toLowerCase()
|
||||
})
|
||||
Handlebars.registerHelper('upperFirst', function (text) {
|
||||
if (typeof text !== 'string') return text
|
||||
return text.charAt(0).toUpperCase() + text.slice(1)
|
||||
})
|
||||
Handlebars.registerHelper('notEmpty', function (list) {
|
||||
return list.length > 0;
|
||||
})
|
||||
Handlebars.registerHelper('mul', function (a, b) {
|
||||
return parseInt(a) * parseInt(b);
|
||||
})
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static pushInitiativeOptions(html, options) {
|
||||
console.log('Option pushed....')
|
||||
options.push({ name: "Apply -10", condition: true, icon: '<i class="fas fa-plus"></i>', callback: target => { PegasusCombat.decInitBy10(target.data('combatant-id'), -10); } })
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getSpecs() {
|
||||
return this.specs;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async ready() {
|
||||
const specs = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.specialisations");
|
||||
this.specs = specs.map(i => i.toObject());
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async addItemDropToActor(actor, item) {
|
||||
actor.preprocessItem("none", item, false)
|
||||
let chatData = {
|
||||
user: game.user.id,
|
||||
rollMode: game.settings.get("core", "rollMode"),
|
||||
whisper: [game.user.id].concat(ChatMessage.getWhisperRecipients('GM')),
|
||||
content: `<div>The item ${item.name} has been dropped on the actor ${actor.name}</div`
|
||||
}
|
||||
ChatMessage.create(chatData);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async dropItemOnToken(canvas, data) {
|
||||
if (data.type != "Item") {
|
||||
return
|
||||
}
|
||||
|
||||
const position = canvas.grid.getTopLeft(data.x, data.y)
|
||||
let x = position[0]
|
||||
let y = position[1]
|
||||
const tokensList = [...canvas.tokens.placeables]
|
||||
for (let token of tokensList) {
|
||||
if (x >= token.x && x <= (token.x + token.width)
|
||||
&& y >= token.y && y <= (token.y + token.height)) {
|
||||
let item = await this.searchItem(data)
|
||||
if (game.user.isGM || token.actor.isOwner) {
|
||||
this.addItemDropToActor(token.actor, item)
|
||||
} else {
|
||||
game.socket.emit("system.fvtt-pegasus-rpg", { name: "msg_gm_item_drop", data: { actorId: token.actor.id, itemId: item.id, isPack: item.pack } })
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async loadCompendiumData(compendium) {
|
||||
const pack = game.packs.get(compendium);
|
||||
return await pack?.getDocuments() ?? [];
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async loadCompendium(compendium, filter = item => true) {
|
||||
let compendiumData = await PegasusUtility.loadCompendiumData(compendium);
|
||||
return compendiumData.filter(filter);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static buildDiceLists() {
|
||||
let maxLevel = game.settings.get("fvtt-pegasus-rpg", "dice-max-level");
|
||||
let diceList = ["0"];
|
||||
let diceValues = [0];
|
||||
let diceFoundryList = ["d0"];
|
||||
let diceLevel = 1;
|
||||
let concat = "";
|
||||
let concatFoundry = "";
|
||||
let optionsDiceList = '<option value="0">0</option>';
|
||||
let optionsLevel = '<option value="0">0</option>';
|
||||
for (let i = 1; i <= maxLevel; i++) {
|
||||
let currentDices = concat + __level2Dice[diceLevel];
|
||||
diceList.push(currentDices);
|
||||
diceFoundryList.push(concatFoundry + __level2Dice[diceLevel] + "x");
|
||||
if (__level2Dice[diceLevel] == "d12") {
|
||||
concat = concat + "d12 ";
|
||||
concatFoundry = concatFoundry + "d12x, ";
|
||||
diceLevel = 1;
|
||||
} else {
|
||||
diceLevel++;
|
||||
}
|
||||
optionsDiceList += `<option value="${i}">${currentDices}</option>`;
|
||||
optionsLevel += `<option value="${i}">${i}</option>`;
|
||||
}
|
||||
this.diceList = diceList;
|
||||
this.diceFoundryList = diceFoundryList;
|
||||
this.optionsDiceList = optionsDiceList;
|
||||
this.optionsLevel = optionsLevel;
|
||||
|
||||
this.optionsStatusList = '<option value="notapplicable">Not applicable</option><option value="health">Health</option><option value="nrg">NRG</option><option value="delirium">Delirium</option>';
|
||||
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getOptionsStatusList() {
|
||||
return this.optionsStatusList;
|
||||
}
|
||||
/* -------------------------------------------- */
|
||||
static getOptionsDiceList() {
|
||||
return this.optionsDiceList;
|
||||
}
|
||||
/* -------------------------------------------- */
|
||||
static getOptionsLevel() {
|
||||
return this.optionsLevel;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static computeAttackDefense(defenseRollId) {
|
||||
let defenseRollData = this.getRollData(defenseRollId);
|
||||
let attackRollData = this.getRollData(defenseRollData.linkedRollId);
|
||||
let defender = game.actors.get(defenseRollData.actorId);
|
||||
defender.processDefenseResult(defenseRollData, attackRollData);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static applyDamage(defenseRollId) {
|
||||
let defenseRollData = this.getRollData(defenseRollId);
|
||||
let defender = game.actors.get(defenseRollData.actorId);
|
||||
defender.applyDamageLoss(defenseRollData.finalDamage);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static applyNoDefense(actorId, attackRollId) {
|
||||
let attackRollData = this.getRollData(attackRollId);
|
||||
let defender = game.actors.get(actorId);
|
||||
defender.processNoDefense(attackRollData);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async chatListeners(html) {
|
||||
|
||||
html.on("click", '.chat-create-actor', event => {
|
||||
game.system.pegasus.creator.processChatEvent(event);
|
||||
});
|
||||
html.on("click", '.view-item-from-chat', event => {
|
||||
game.system.pegasus.creator.openItemView(event)
|
||||
});
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async preloadHandlebarsTemplates() {
|
||||
|
||||
const templatePaths = [
|
||||
'systems/fvtt-pegasus-rpg/templates/editor-notes-gm.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-roll-select-effects.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-options-statistics.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-options-level.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-options-range.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-options-equipment-types.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-equipment-effects.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-actor-stat-block.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-actor-status.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-item-nav.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-item-description.html',
|
||||
'systems/fvtt-pegasus-rpg/templates/partial-actor-equipment.html'
|
||||
]
|
||||
return loadTemplates(templatePaths);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async getEffectFromCompendium(effectName) {
|
||||
effectName = effectName.toLowerCase()
|
||||
let effect = game.items.contents.find(item => item.type == 'effect' && item.name.toLowerCase() == effectName)
|
||||
if (!effect) {
|
||||
let effects = await this.loadCompendium('fvtt-pegasus.effect', item => item.name.toLowerCase() == effectName)
|
||||
let objs = effects.map(i => i.toObject())
|
||||
effect = objs[0]
|
||||
} else {
|
||||
effect = duplicate(effect);
|
||||
}
|
||||
|
||||
console.log("Effect", effect)
|
||||
return effect
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static removeChatMessageId(messageId) {
|
||||
if (messageId) {
|
||||
game.messages.get(messageId)?.delete();
|
||||
}
|
||||
}
|
||||
|
||||
static findChatMessageId(current) {
|
||||
return PegasusUtility.getChatMessageId(PegasusUtility.findChatMessage(current));
|
||||
}
|
||||
|
||||
static getChatMessageId(node) {
|
||||
return node?.attributes.getNamedItem('data-message-id')?.value;
|
||||
}
|
||||
|
||||
static findChatMessage(current) {
|
||||
return PegasusUtility.findNodeMatching(current, it => it.classList.contains('chat-message') && it.attributes.getNamedItem('data-message-id'));
|
||||
}
|
||||
|
||||
static findNodeMatching(current, predicate) {
|
||||
if (current) {
|
||||
if (predicate(current)) {
|
||||
return current;
|
||||
}
|
||||
return PegasusUtility.findNodeMatching(current.parentElement, predicate);
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static templateData(it) {
|
||||
return PegasusUtility.data(it)?.data ?? {}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static data(it) {
|
||||
if (it instanceof Actor || it instanceof Item || it instanceof Combatant) {
|
||||
return it.data;
|
||||
}
|
||||
return it;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getDiceValue(level = 0) {
|
||||
let diceString = this.diceList[level]
|
||||
let diceTab = diceString.split(" ")
|
||||
let diceValue = 0
|
||||
for (let dice of diceTab) {
|
||||
diceValue += __name2DiceValue[dice]
|
||||
}
|
||||
return diceValue
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getDiceFromLevel(level = 0) {
|
||||
level = Number(level)
|
||||
return this.diceList[level];
|
||||
}
|
||||
/* -------------------------------------------- */
|
||||
static getFoundryDiceFromLevel(level = 0) {
|
||||
level = Number(level)
|
||||
//console.log(this.diceFoundryList);
|
||||
return this.diceFoundryList[level];
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static createDirectOptionList(min, max) {
|
||||
let options = {};
|
||||
for (let i = min; i <= max; i++) {
|
||||
options[`${i}`] = `${i}`;
|
||||
}
|
||||
return options;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static buildListOptions(min, max) {
|
||||
let options = ""
|
||||
for (let i = min; i <= max; i++) {
|
||||
options += `<option value="${i}">${i}</option>`
|
||||
}
|
||||
return options;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getTarget() {
|
||||
if (game.user.targets && game.user.targets.size == 1) {
|
||||
for (let target of game.user.targets) {
|
||||
return target;
|
||||
}
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getDefenseState(actorId) {
|
||||
return this.defenderStore[actorId];
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async updateDefenseState(defenderId, rollId) {
|
||||
this.defenderStore[defenderId] = rollId;
|
||||
if (game.user.character && game.user.character.id == defenderId) {
|
||||
let defender = game.actors.get(defenderId);
|
||||
let chatData = {
|
||||
user: game.user.id,
|
||||
alias: defender.name,
|
||||
rollMode: game.settings.get("core", "rollMode"),
|
||||
whisper: [game.user.id].concat(ChatMessage.getWhisperRecipients('GM')),
|
||||
content: `<div>${defender.name} is under attack. He must roll a skill/weapon/technique to defend himself or suffer damages (button below).
|
||||
<button class="chat-card-button apply-nodefense" data-actor-id="${defenderId}" data-roll-id="${rollId}" >No defense</button></div`
|
||||
};
|
||||
//console.log("Apply damage chat", chatData );
|
||||
await ChatMessage.create(chatData);
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static updateRollData(rollData) {
|
||||
|
||||
let id = rollData.rollId;
|
||||
let oldRollData = this.rollDataStore[id] || {};
|
||||
let newRollData = mergeObject(oldRollData, rollData);
|
||||
this.rollDataStore[id] = newRollData;
|
||||
}
|
||||
/* -------------------------------------------- */
|
||||
static saveRollData(rollData) {
|
||||
game.socket.emit("system.pegasus-rpg", {
|
||||
name: "msg_update_roll", data: rollData
|
||||
}); // Notify all other clients of the roll
|
||||
this.updateRollData(rollData);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getRollData(id) {
|
||||
return this.rollDataStore[id];
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async onSocketMesssage(msg) {
|
||||
console.log("SOCKET MESSAGE", msg.name)
|
||||
if (msg.name == "msg_update_defense_state") {
|
||||
this.updateDefenseState(msg.data.defenderId, msg.data.rollId)
|
||||
}
|
||||
if (msg.name == "msg_update_roll") {
|
||||
this.updateRollData(msg.data)
|
||||
}
|
||||
if (msg.name == "msg_gm_item_drop" && game.user.isGM) {
|
||||
let actor = game.actors.get( msg.data.actorId )
|
||||
let item
|
||||
if (msg.data.isPack) {
|
||||
item = await fromUuid("Compendium." + msg.data.isPack + "." + msg.data.itemId)
|
||||
} else {
|
||||
item = game.items.get(msg.data.itemId)
|
||||
}
|
||||
this.addItemDropToActor( actor, item )
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static chatDataSetup(content, modeOverride, isRoll = false, forceWhisper) {
|
||||
let chatData = {
|
||||
user: game.user.id,
|
||||
rollMode: modeOverride || game.settings.get("core", "rollMode"),
|
||||
content: content
|
||||
};
|
||||
|
||||
if (["gmroll", "blindroll"].includes(chatData.rollMode)) chatData["whisper"] = ChatMessage.getWhisperRecipients("GM").map(u => u.id);
|
||||
if (chatData.rollMode === "blindroll") chatData["blind"] = true;
|
||||
else if (chatData.rollMode === "selfroll") chatData["whisper"] = [game.user];
|
||||
|
||||
if (forceWhisper) { // Final force !
|
||||
chatData["speaker"] = ChatMessage.getSpeaker();
|
||||
chatData["whisper"] = ChatMessage.getWhisperRecipients(forceWhisper);
|
||||
}
|
||||
|
||||
return chatData;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async loadCompendiumData(compendium) {
|
||||
const pack = game.packs.get(compendium);
|
||||
return await pack?.getDocuments() ?? [];
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async loadCompendium(compendium, filter = item => true) {
|
||||
let compendiumData = await this.loadCompendiumData(compendium);
|
||||
//console.log("Compendium", compendiumData);
|
||||
return compendiumData.filter(filter);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async showDiceSoNice(roll, rollMode) {
|
||||
if (game.modules.get("dice-so-nice")?.active) {
|
||||
if (game.dice3d) {
|
||||
let whisper = null;
|
||||
let blind = false;
|
||||
rollMode = rollMode ?? game.settings.get("core", "rollMode");
|
||||
switch (rollMode) {
|
||||
case "blindroll": //GM only
|
||||
blind = true;
|
||||
case "gmroll": //GM + rolling player
|
||||
whisper = this.getUsers(user => user.isGM);
|
||||
break;
|
||||
case "roll": //everybody
|
||||
whisper = this.getUsers(user => user.active);
|
||||
break;
|
||||
case "selfroll":
|
||||
whisper = [game.user.id];
|
||||
break;
|
||||
}
|
||||
await game.dice3d.showForRoll(roll, game.user, true, whisper, blind);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static removeUsedPerkEffects(rollData) {
|
||||
// De-actived used effects from perks
|
||||
let toRem = []
|
||||
for (let effect of rollData.effectsList) {
|
||||
if (effect.effect.data.perkId && effect.effect.data.isUsed) {
|
||||
toRem.push(effect.effect._id)
|
||||
}
|
||||
}
|
||||
if (toRem.length > 0) {
|
||||
let actor = game.actors.get(rollData.actorId)
|
||||
actor.deleteEmbeddedDocuments('Item', toRem)
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async rollPegasus(rollData) {
|
||||
|
||||
let dicePool = [{ name: "stat", level: 0, statmod: 0 }, { name: "spec", level: 0 }, { name: "bonus", level: 0 }, { name: "hindrance", level: 0 }, { name: "other", level: 0 }];
|
||||
if (rollData.stat) {
|
||||
dicePool[0].level += Number(rollData.stat.value);
|
||||
dicePool[0].statmod = Number(rollData.stat.mod);
|
||||
}
|
||||
if (rollData.statDicesLevel) {
|
||||
dicePool[0].level = rollData.statDicesLevel;
|
||||
}
|
||||
if (rollData.selectedSpec && rollData.selectedSpec != "0") {
|
||||
rollData.spec = rollData.specList.find(item => item._id == rollData.selectedSpec);
|
||||
rollData.spec.data.dice = PegasusUtility.getDiceFromLevel(rollData.spec.data.level);
|
||||
}
|
||||
if (rollData.spec) {
|
||||
dicePool[1].level += Number(rollData.spec.data.level);
|
||||
}
|
||||
if (rollData.specDicesLevel) {
|
||||
dicePool[1].level = rollData.specDicesLevel;
|
||||
}
|
||||
if (rollData.bonusDicesLevel) {
|
||||
dicePool[2].level += Number(rollData.bonusDicesLevel);
|
||||
}
|
||||
if (rollData.hindranceDicesLevel) {
|
||||
dicePool[3].level += Number(rollData.hindranceDicesLevel);
|
||||
}
|
||||
if (rollData.otherDicesLevel) {
|
||||
dicePool[4].level += Number(rollData.otherDicesLevel);
|
||||
}
|
||||
|
||||
let diceFormulaTab = [];
|
||||
for (let diceGroup of dicePool) {
|
||||
diceFormulaTab.push(this.getFoundryDiceFromLevel(diceGroup.level))
|
||||
}
|
||||
let diceFormula = '{' + diceFormulaTab.join(', ') + '}kh';
|
||||
|
||||
// Performs roll
|
||||
let myRoll = rollData.roll;
|
||||
if (!myRoll) { // New rolls only of no rerolls
|
||||
myRoll = new Roll(diceFormula).roll({ async: false });
|
||||
console.log("ROLL : ", diceFormula)
|
||||
await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"));
|
||||
rollData.roll = myRoll
|
||||
}
|
||||
|
||||
// Final score and keep data
|
||||
rollData.finalScore = myRoll.total + dicePool[0].statmod;
|
||||
|
||||
if (rollData.damages) {
|
||||
let dmgFormula = this.getFoundryDiceFromLevel(rollData.damages.value)
|
||||
let dmgRoll = new Roll(dmgFormula).roll({ async: false });
|
||||
await this.showDiceSoNice(dmgRoll, game.settings.get("core", "rollMode"));
|
||||
rollData.dmgResult = dmgRoll.total;
|
||||
}
|
||||
|
||||
this.createChatWithRollMode(rollData.alias, {
|
||||
content: await renderTemplate(`systems/fvtt-pegasus-rpg/templates/chat-generic-result.html`, rollData)
|
||||
});
|
||||
|
||||
// Init stuf
|
||||
if (rollData.isInit) {
|
||||
let combat = game.combats.get(rollData.combatId)
|
||||
combat.updateEmbeddedDocuments("Combatant", [{ _id: rollData.combatantId, initiative: rollData.finalScore }]);
|
||||
}
|
||||
|
||||
//this.removeUsedPerkEffects( rollData) // Unused for now
|
||||
|
||||
// And save the roll
|
||||
this.saveRollData(rollData);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getDamageDice(result) {
|
||||
if (result < 0) return 0;
|
||||
return Math.floor(result / 5) + 1;
|
||||
}
|
||||
|
||||
/* ------------------------- ------------------- */
|
||||
static async updateRoll(rollData) {
|
||||
|
||||
let diceResults = rollData.diceResults;
|
||||
let sortedRoll = [];
|
||||
for (let i = 0; i < 10; i++) {
|
||||
sortedRoll[i] = 0;
|
||||
}
|
||||
for (let dice of diceResults) {
|
||||
sortedRoll[dice.result]++;
|
||||
}
|
||||
let index = 0;
|
||||
let bestRoll = 0;
|
||||
for (let i = 0; i < 10; i++) {
|
||||
if (sortedRoll[i] > bestRoll) {
|
||||
bestRoll = sortedRoll[i];
|
||||
index = i;
|
||||
}
|
||||
}
|
||||
let bestScore = (bestRoll * 10) + index
|
||||
rollData.bestScore = bestScore
|
||||
rollData.finalScore = bestScore + rollData.negativeModifier + rollData.positiveModifier
|
||||
|
||||
this.saveRollData(rollData)
|
||||
|
||||
this.createChatWithRollMode(rollData.alias, {
|
||||
content: await renderTemplate(`systems/fvtt-weapons-of-the-gods/templates/chat-generic-result.html`, rollData)
|
||||
});
|
||||
}
|
||||
|
||||
/* ------------------------- ------------------- */
|
||||
static async rerollDice(actorId, diceIndex = -1) {
|
||||
let actor = game.actors.get(actorId);
|
||||
let rollData = actor.getRollData();
|
||||
|
||||
if (diceIndex == -1) {
|
||||
rollData.hasWillpower = actor.decrementWillpower();
|
||||
rollData.roll = undefined;
|
||||
} else {
|
||||
let myRoll = new Roll("1d6").roll({ async: false });
|
||||
await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"));
|
||||
console.log("Result: ", myRoll);
|
||||
|
||||
rollData.roll.dice[0].results[diceIndex].result = myRoll.total; // Patch
|
||||
rollData.nbStrongHitUsed++;
|
||||
}
|
||||
this.rollFraggedKingdom(rollData);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getUsers(filter) {
|
||||
return game.users.filter(filter).map(user => user.data._id);
|
||||
}
|
||||
/* -------------------------------------------- */
|
||||
static getWhisperRecipients(rollMode, name) {
|
||||
switch (rollMode) {
|
||||
case "blindroll": return this.getUsers(user => user.isGM);
|
||||
case "gmroll": return this.getWhisperRecipientsAndGMs(name);
|
||||
case "selfroll": return [game.user.id];
|
||||
}
|
||||
return undefined;
|
||||
}
|
||||
/* -------------------------------------------- */
|
||||
static getWhisperRecipientsAndGMs(name) {
|
||||
let recep1 = ChatMessage.getWhisperRecipients(name) || [];
|
||||
return recep1.concat(ChatMessage.getWhisperRecipients('GM'));
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static blindMessageToGM(chatOptions) {
|
||||
let chatGM = duplicate(chatOptions);
|
||||
chatGM.whisper = this.getUsers(user => user.isGM);
|
||||
chatGM.content = "Blinde message of " + game.user.name + "<br>" + chatOptions.content;
|
||||
console.log("blindMessageToGM", chatGM);
|
||||
game.socket.emit("system.fvtt-pegasus-rgp", { msg: "msg_gm_chat_message", data: chatGM });
|
||||
}
|
||||
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async searchItem(dataItem) {
|
||||
let item
|
||||
if (dataItem.pack) {
|
||||
item = await fromUuid("Compendium." + dataItem.pack + "." + dataItem.id)
|
||||
} else {
|
||||
item = game.items.get(dataItem.id)
|
||||
}
|
||||
return item
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static split3Columns(data) {
|
||||
|
||||
let array = [[], [], []];
|
||||
if (data == undefined) return array;
|
||||
|
||||
let col = 0;
|
||||
for (let key in data) {
|
||||
let keyword = data[key];
|
||||
keyword.key = key; // Self-reference
|
||||
array[col].push(keyword);
|
||||
col++;
|
||||
if (col == 3) col = 0;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static createChatMessage(name, rollMode, chatOptions) {
|
||||
switch (rollMode) {
|
||||
case "blindroll": // GM only
|
||||
if (!game.user.isGM) {
|
||||
this.blindMessageToGM(chatOptions);
|
||||
|
||||
chatOptions.whisper = [game.user.id];
|
||||
chatOptions.content = "Message only to the GM";
|
||||
}
|
||||
else {
|
||||
chatOptions.whisper = this.getUsers(user => user.isGM);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
chatOptions.whisper = this.getWhisperRecipients(rollMode, name);
|
||||
break;
|
||||
}
|
||||
chatOptions.alias = chatOptions.alias || name;
|
||||
ChatMessage.create(chatOptions);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static getBasicRollData() {
|
||||
let rollData = {
|
||||
rollId: randomID(16),
|
||||
rollMode: game.settings.get("core", "rollMode"),
|
||||
bonusDicesLevel: 0,
|
||||
hindranceDicesLevel: 0,
|
||||
otherDicesLevel: 0,
|
||||
statDicesLevel: 0,
|
||||
specDicesLevel: 0,
|
||||
effectsList: [],
|
||||
armorsList: [],
|
||||
weaponsList: [],
|
||||
equipmentsList: [],
|
||||
optionsDiceList: PegasusUtility.getOptionsDiceList()
|
||||
}
|
||||
PegasusUtility.updateWithTarget(rollData)
|
||||
return rollData
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static updateWithTarget(rollData) {
|
||||
let objectDefender
|
||||
let target = PegasusUtility.getTarget();
|
||||
if (target) {
|
||||
let defenderActor = game.actors.get(target.data.actorId)
|
||||
objectDefender = PegasusUtility.data(defenderActor)
|
||||
objectDefender = mergeObject(objectDefender, target.data.actorData)
|
||||
rollData.defender = objectDefender
|
||||
rollData.attackerId = this.id
|
||||
rollData.defenderId = objectDefender._id
|
||||
defenderActor.addHindrancesList(rollData.effectsList)
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static createChatWithRollMode(name, chatOptions) {
|
||||
this.createChatMessage(name, game.settings.get("core", "rollMode"), chatOptions);
|
||||
}
|
||||
|
||||
/* -------------------------------------------- */
|
||||
static async confirmDelete(actorSheet, li) {
|
||||
let itemId = li.data("item-id");
|
||||
let msgTxt = "<p>Are you sure to remove this Item ?";
|
||||
let buttons = {
|
||||
delete: {
|
||||
icon: '<i class="fas fa-check"></i>',
|
||||
label: "Yes, remove it",
|
||||
callback: () => {
|
||||
actorSheet.actor.deleteEmbeddedDocuments("Item", [itemId]);
|
||||
li.slideUp(200, () => actorSheet.render(false));
|
||||
}
|
||||
},
|
||||
cancel: {
|
||||
icon: '<i class="fas fa-times"></i>',
|
||||
label: "Cancel"
|
||||
}
|
||||
}
|
||||
msgTxt += "</p>";
|
||||
let d = new Dialog({
|
||||
title: "Confirm removal",
|
||||
content: msgTxt,
|
||||
buttons: buttons,
|
||||
default: "cancel"
|
||||
});
|
||||
d.render(true);
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user