${spendingActor.name} wants to spend ${data.tokenCost} adversity tokens on ${rollActor.name}'s roll to increase it by ${data.tokensToSpend}. Approve?
`, + buttons: { + yes: { + label: "Yes", + callback: async () => { + + + const currentTokens = spendingActor.system.adversityTokens || 0; + + // Update the spending actor's adversity token count + await spendingActor.update({ "system.adversityTokens": currentTokens - data.tokenCost }); + + + // Modify the roll message with the new total + await _updateRollMessage(data.rollMessageId, data.tokensToSpend, false); + + console.log(`${spendingActor.name} spent ${data.tokensToSpend} tokens, updated roll total to ${roll.cumulativeTotal}`); + ui.notifications.info(`${spendingActor.name} successfully spent ${data.tokensToSpend} tokens.`); + } + }, + no: { + label: "No", + callback: () => { + ui.notifications.info(`The GM denied ${spendingActor.name}'s request to spend tokens.`); + } + } + }, + default: "yes" + }).render(true); + } else if (data.action === "takeToken") { + // Only handle the request if the GM is logged in + if (!game.user.isGM) { + console.log("Not GM, ignoring the token spend request."); + return; + } + let tokenControls = game.messages.get(data.messageID); + console.log(tokenControls); + // Update the chat message content with the button disabled and text changed + const updatedContent = tokenControls.content.replace( + ``, + `` + ); + console.log("Removing Button"); + // Update the message content + tokenControls.update({ content: updatedContent }); + // Set the flag on the chat message to indicate that the token has been claimed + tokenControls.setFlag("kids-on-brooms", "tokenClaimed", true); + } + }); +}); + +/*** + * This function adds the adversity token to the actor that made the roll and logs it + * + * @param {Event} e - The button click event + * @param {Actor} actor - The actor object that made the roll + */ +async function _onTakeAdversityToken(e, actor) { + e.preventDefault(); + + + // Get the chat message ID (assuming it's stored in the dataset) + const messageId = e.currentTarget.closest('.message').dataset.messageId; + const message = game.messages.get(messageId); + + // Add an adversity token to the actor + const currentTokens = actor.system.adversityTokens || 0; + await actor.update({ "system.adversityTokens": currentTokens + 1 }); + + + // Notify the user + ui.notifications.info(`You gained 1 adversity token.`); + console.log(`Gave one adversity token to ${actor.id}`) +} + +/*** + * This function allows players to spend tokens to change a roll. This will automatically be calculated in their sheet + * + */ +async function _onSpendAdversityTokens(e, rollMessageId) { + e.preventDefault(); + + // The actor who made the roll + const rollActorId = e.currentTarget.dataset.actorId; + const rollActor = game.actors.get(rollActorId); //technically redundant since it is also done in the main hook, but perfomance is good enuff + + // Get the actor of the player who is spending tokens + const spendingPlayerActor = game.actors.get(game.user.character?.id || game.actors.filter(actor => actor.testUserPermission(game.user, "owner"))[0]?.id); + + if (!spendingPlayerActor) { + ui.notifications.warn("You don't control any actors."); + return; + } + + //Get the tokens to be spend from the input field + const tokenInput = $(e.currentTarget).closest('.adversity-controls').find('.token-input').val(); + const tokensToSpend = parseInt(tokenInput, 10); + + if (isNaN(tokensToSpend) || tokensToSpend <= 0) { + ui.notifications.warn("Please enter a valid number of tokens."); + return; + } + + let tokenCost = tokensToSpend; + + // If the player spending tokens is not the owner of the actor who rolled, they spend double + //(note, this is a rule of mine, I have disabled it by default) + if ((!spendingPlayerActor.testUserPermission(game.user, "owner") || spendingPlayerActor.id !== rollActorId) && false) { + tokenCost = tokensToSpend * 2; + } + + // Ensure the spending actor has enough adversity tokens + if (spendingPlayerActor.system.adversityTokens < tokenCost) { + ui.notifications.warn(`You do not have enough adversity tokens.`); + return; + } + + // Check if the player owns the actor who made the roll + if (spendingPlayerActor.id === rollActorId) { + // The player owns the actor, so they can spend tokens directly without GM approval + const currentTokens = spendingPlayerActor.system.adversityTokens || 0; + + // Deduct the tokens from the player + await spendingPlayerActor.update({ "system.adversityTokens": currentTokens - tokenCost }); + + // Modify the roll message with the new total + await _updateRollMessage(rollMessageId, tokensToSpend, true); + + } else { + // The player does not own the actor, so request GM approval to spend the tokens + console.log(`Requesting to spend ${tokensToSpend} tokens for ${rollActor.name} by ${spendingPlayerActor.name} (cost: ${tokenCost})`); + + // Emit a socket request to spend tokens + game.socket.emit('system.kids-on-brooms', { + action: "spendTokens", + rollActorId: rollActorId, + spendingActorId: spendingPlayerActor.id, // Send the player's actor who is spending the tokens + tokensToSpend: tokensToSpend, + tokenCost: tokenCost, + rollMessageId: rollMessageId // Pass message ID to update the roll result + }); + + ui.notifications.info(`Requested to spend ${tokenCost} tokens for ${rollActor.name}`); + } +} + +// Helper function to send a new message with the updated roll result +async function _updateRollMessage(rollMessageId, tokensToSpend, isPlayerOfActor) { + const message = game.messages.get(rollMessageId); + + if (!message) { + console.error("Message not found with ID:", rollMessageId); + return; + } + + // Retrieve current tokens spent from flags, or initialize to 0 if not found + let cumulativeTokensSpent = message.getFlag("kids-on-brooms", "tokensSpent") || 0; + let newTotal = message.getFlag("kids-on-brooms", "newRollTotal") || message.rolls[0].total; + + /*if(isPlayerOfActor) + { + // Add the new tokens to the cumulative total + cumulativeTokensSpent += tokensToSpend; + } else { + cumulativeTokensSpent += 2*tokensToSpend; + }*/ + cumulativeTokensSpent += tokensToSpend; + newTotal += tokensToSpend; + await message.setFlag("kids-on-brooms", "newRollTotal", newTotal); + + // Update the message's flags to store the cumulative tokens spent + await message.setFlag("kids-on-brooms", "tokensSpent", cumulativeTokensSpent); + let newContent = ""; + if(cumulativeTokensSpent === 1) + { + newContent = `You have now spent ${cumulativeTokensSpent} token. The new roll total is ${newTotal}.`; + } else { + newContent = `You have now spent ${cumulativeTokensSpent} tokens. The new roll total is ${newTotal}.`; + } + + // Create a new chat message to display the updated total + await ChatMessage.create({ + speaker: ChatMessage.getSpeaker({ actor: message.speaker.actor }), + content: newContent, + type: CONST.CHAT_MESSAGE_STYLES.OTHER, + }); +} \ No newline at end of file diff --git a/module/sheets/actor-sheet.mjs b/module/sheets/actor-sheet.mjs new file mode 100644 index 0000000..021f9d9 --- /dev/null +++ b/module/sheets/actor-sheet.mjs @@ -0,0 +1,147 @@ +/** + * Extend the basic ActorSheet with some very simple modifications + * @extends {ActorSheet} + */ +export class KidsOnBroomsActorSheet extends ActorSheet { + + /** @override */ + static get defaultOptions() + { + return foundry.utils.mergeObject(super.defaultOptions, { + classes: ["kids-on-brooms", "sheet", "actor"], + width: 800, + height: 800, + tabs: [{ navSelector: ".sheet-tabs", contentSelector: ".sheet-body", initial: "features" }] + }); + } + + /** @override */ + get template() + { + console.log("template", this.actor) + return `systems/kids-on-brooms/templates/actor/actor-${this.actor.type}-sheet.html`; + } + + /* -------------------------------------------- */ + + /** @override */ + /** @override */ +async getData() +{ + // Retrieve the data structure from the base sheet. + const context = super.getData(); + + // Use a safe clone of the actor data for further operations. + const actorData = this.document.toObject(false); + + // Add the actor's data to context.data for easier access, as well as flags. + context.system = actorData.system; + context.flags = actorData.flags; + + // Add roll data for TinyMCE editors. + context.rollData = context.actor.getRollData(); + // Add roll data for TinyMCE editors. + context.rollData = context.actor.getRollData(); + + + console.log(context); + return context; +} + + /* -------------------------------------------- */ + + /** @override */ + activateListeners(html) + { + super.activateListeners(html); + // ------------------------------------------------------------- + // Everything below here is only needed if the sheet is editable + if (!this.isEditable) return; + + // Rollable abilities. + html.find('.rollable').click(this._onRoll.bind(this)); + + //If the user changes their wand material save that + html.find('select[name="system.wand.wood"]').change(event => { + const value = event.target.value; + this.actor.update({ "system.wand.wood": value }); + }); + + html.find('select[name="system.wand.core"]').change(event => { + const value = event.target.value; + this.actor.update({ "system.wand.core": value }); + }); +} + + /** + * Handle clickable rolls. + * @param {Event} event The originating click event + * @private + */ + async _onRoll(e) { + e.preventDefault(); + const element = e.currentTarget; + const dataset = element.dataset; + + // Handle rolls that supply the formula directly + if (dataset.roll) { + let label = dataset.label ? `${dataset.label}` : ''; + // Get the roll data and include wand bonuses + let rollData = this.actor.getRollData(); + let totalBonus = 0; + console.log(dataset.roll); + // Apply wood bonus if it matches the stat being rolled for + if (rollData.wandBonus.wood.stat === dataset.key) { + totalBonus += rollData.wandBonus.wood.bonus; + } + + // Apply core bonus if it matches the stat being rolled for AND it's different from the wood bonus + if (rollData.wandBonus.core.stat === dataset.key && rollData.wandBonus.core.stat !== rollData.wandBonus.wood.stat) { + totalBonus += rollData.wandBonus.core.bonus; + } + let rollFormula = dataset.roll + `+${totalBonus}`; + let roll = new Roll(rollFormula, rollData); + console.log(rollFormula); + console.log(rollData); + + // Send the roll message to chat + const rollMessage = await roll.toMessage({ + speaker: ChatMessage.getSpeaker({ actor: this.actor }), + flavor: label, + rollMode: game.settings.get('core', 'rollMode'), + }) + + // Now send the follow-up message with the adversity controls + await this._sendAdversityControlsMessage(this.actor.id, rollMessage.id); + + return roll; + } + } + + //This just sends the buttons for the adversity token system + async _sendAdversityControlsMessage(actorId, rollMessageId) { + // Create the content for the adversity controls + const adversityControlsHtml = this._createAdversityControls(actorId, rollMessageId); + + // Send the adversity controls as a follow-up message + const controlMessage = await ChatMessage.create({ + speaker: ChatMessage.getSpeaker({ actor: this.actor }), + content: adversityControlsHtml, + }); + + return controlMessage; + } + + // Create HTML content for adversity controls + _createAdversityControls(actorId, rollMessageId) { + return ` +