public/fvtt-mournblade
1
0
Fork 0
Code Issues Pull Requests Projects Releases 37 Wiki Activity

Automatisations de combats, WIP

Browse Source
This commit is contained in:
LeRatierBretonnien
2023-12-22 09:30:26 +01:00
parent e1816b3dd7
commit 91ad26730a
81 changed files with 475 additions and 240 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
modules/mournblade-actor-sheet.js
View File

@@ -56,6 +56,7 @@ export class MournbladeActorSheet extends ActorSheet {
equipements: duplicate(this.actor.getEquipments()),
monnaies: duplicate(this.actor.getMonnaies()),
runeEffects: duplicate(this.actor.getRuneEffects()),
config: game.system.mournblade.config,
description: await TextEditor.enrichHTML(this.object.system.biodata.description, {async: true}),
options: this.options,
owner: this.document.isOwner,

13
modules/mournblade-actor.js
View File

@@ -52,6 +52,7 @@ export class MournbladeActor extends Actor {
arme = duplicate(arme)
let combat = this.getCombatValues()
if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
arme.system.isMelee = true
arme.system.competence = duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
arme.system.attrKey = "pui"
arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
@@ -61,6 +62,7 @@ export class MournbladeActor extends Actor {
}
}
if (arme.system.typearme == "jet" || arme.system.typearme == "tir") {
arme.system.isDistance = true
arme.system.competence = duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "armes à distance"))
arme.system.attrKey = "adr"
arme.system.totalOffensif = this.system.attributs.adr.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
@@ -414,6 +416,7 @@ export class MournbladeActor extends Actor {
rollData.canEclatDoubleD20 = this.canEclatDoubleD20()
rollData.doubleD20 = false
rollData.attributs = MournbladeUtility.getAttributs()
rollData.selectDifficulte = true
if (attrKey) {
rollData.attrKey = attrKey
@@ -476,6 +479,15 @@ export class MournbladeActor extends Actor {
}
let rollData = this.getCommonRollData(arme.system.attrKey, arme.system.competence._id)
rollData.arme = arme
rollData.typeAttaque = "assaut"
rollData.typeCouvert = "aucun"
rollData.visee = false
rollData.ciblecourt = false
rollData.cibleconsciente = false
// Do not display difficulte if defense weapon or distance
if (rollData.armeDefense || rollData.arme.system.isDistance) {
rollData.selectDifficulte = false
}
console.log("ARME!", rollData)
let rollDialog = await MournbladeRollDialog.create(this, rollData)
rollDialog.render(true)
@@ -490,6 +502,7 @@ export class MournbladeActor extends Actor {
if (arme.type == "bouclier") {
arme = this.prepareBouclier(arme)
}
rollData.degatsFormula = arme.system.totalDegats
let roll = new Roll(arme.system.totalDegats).roll({ async: false })
await MournbladeUtility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
let rollData = {

15
modules/mournblade-config.js Normal file
View File

@@ -0,0 +1,15 @@
export const MOURNBLADE_CONFIG = {
attaques:{
assaut: "Assaut",
precise: "Attaque Précise",
feinte: "Feinte",
coupbas: "Coup Bas",
},
couverts:{
aucun: {name: "Aucun", value: 0},
rondache: {name: "Rondache ou léger (-2)", value: -2},
pavois: { name: "Pavois ou à moitié (-5)", value: -5},
complet: {name:"Quasi complet (-10)", value: -10},
}
};

1
modules/mournblade-item-sheet.js
View File

@@ -64,6 +64,7 @@ export class MournbladeItemSheet extends ItemSheet {
options: this.options,
owner: this.document.isOwner,
description: await TextEditor.enrichHTML(this.object.system.description, {async: true}),
config: game.system.mournblade.config,
mr: (this.object.type == 'specialisation'),
isGM: game.user.isGM
}

5
modules/mournblade-main.js
View File

@@ -15,6 +15,7 @@ import { MournbladeActorSheet } from "./mournblade-actor-sheet.js";
import { MournbladeUtility } from "./mournblade-utility.js";
import { MournbladeCombat } from "./mournblade-combat.js";
import { MournbladeItem } from "./mournblade-item.js";
import { MOURNBLADE_CONFIG } from "./mournblade-config.js";
/* -------------------------------------------- */
/* Foundry VTT Initialization */
@@ -45,7 +46,9 @@ Hooks.once("init", async function () {
CONFIG.Combat.documentClass = MournbladeCombat
CONFIG.Actor.documentClass = MournbladeActor
CONFIG.Item.documentClass = MournbladeItem
game.system.mournblade = { }
game.system.mournblade = {
config : MOURNBLADE_CONFIG,
}
/* -------------------------------------------- */
// Register sheet application classes

17
modules/mournblade-roll-dialog.js
View File

@@ -52,7 +52,6 @@ export class MournbladeRollDialog extends Dialog {
activateListeners(html) {
super.activateListeners(html);
var dialog = this;
function onLoad() {
}
$(function () { onLoad(); });
@@ -60,6 +59,9 @@ export class MournbladeRollDialog extends Dialog {
html.find('#modificateur').change(async (event) => {
this.rollData.modificateur = Number(event.currentTarget.value)
})
html.find('#typeAttaque').change(async (event) => {
this.rollData.typeAttaque = String(event.currentTarget.value)
})
html.find('#difficulte').change(async (event) => {
this.rollData.difficulte = Number(event.currentTarget.value)
})
@@ -75,5 +77,18 @@ export class MournbladeRollDialog extends Dialog {
html.find('#doubleD20').change(async (event) => {
this.rollData.doubleD20 = event.currentTarget.checked
})
html.find('#visee').change(async (event) => {
this.rollData.visee = event.currentTarget.checked
})
html.find('#cibleconsciente').change(async (event) => {
this.rollData.cibleconsciente = event.currentTarget.checked
})
html.find('#ciblecourt').change(async (event) => {
this.rollData.ciblecourt = event.currentTarget.checked
})
html.find('#typeCouvert').change(async (event) => {
this.rollData.typeCouvert = String(event.currentTarget.value)
})
}
}

105
modules/mournblade-utility.js
View File

@@ -119,12 +119,12 @@ export class MournbladeUtility {
return this.optionsStatusList;
}
/* -------------------------------------------- */
/* -------------------------------------------- */
static getPredilection(comp, predIdx) {
let pred = duplicate(comp.system.predilections)
return duplicate(pred[predIdx] || {name: "Error!"} )
return duplicate(pred[predIdx] || { name: "Error!" })
}
/* -------------------------------------------- */
static async chatListeners(html) {
@@ -139,6 +139,13 @@ export class MournbladeUtility {
rollData.predilectionUsed = MournbladeUtility.getPredilection(rollData.competence, predIdx)
await MournbladeUtility.rollMournblade(rollData)
})
html.on("click", '.arme-roll-degats', async event => {
let messageId = MournbladeUtility.findChatMessageId(event.currentTarget)
let message = game.messages.get(messageId)
let rollData = message.getFlag("world", "mournblade-roll")
MournbladeUtility.rollDegatsFromAttaque(rollData)
})
}
/* -------------------------------------------- */
@@ -337,10 +344,30 @@ export class MournbladeUtility {
rollData.diceFormula += `+${rollData.attr.value}*2+${rollData.modificateur}`
}
if (rollData.arme && rollData.arme.type == "arme") {
if (rollData.arme?.type == "arme") {
rollData.diceFormula += `+${rollData.arme.system.bonusmaniementoff}`
}
// Specific modifier for distance
if (rollData.arme?.system?.isDistance) {
if (rollData.visee) {
rollData.diceFormula += "+5"
}
if (rollData.cibleconsciente) {
rollData.diceFormula += `-${rollData.defender.system.attributs.adr.value}`
}
if (rollData.ciblecourt) {
if (rollData.difficulte <= 15) { // Portée courte ou moins
rollData.diceFormula += `-5`
} else {
rollData.diceFormula += `-10`
}
}
if (rollData.typeCouvert != "aucun") {
rollData.diceFormula += `-${rollData.config.couverts[rollData.typeCouvert].value}`
}
}
if (rollData.rune) {
rollData.runeduree = Math.ceil((rollData.runeame + 3) / 3)
if (rollData.runemode == "inscrire") {
@@ -374,6 +401,66 @@ export class MournbladeUtility {
}
/* -------------------------------------------- */
static async rollDegatsFromAttaque(rollData) {
let maximize = false
let degatsMessage = "Degats normaux"
if (rollData.arme?.system?.isMelee) {
if (rollData.typeAttaque == "assaut") {
rollData.degatsFormula = rollData.arme.system.totalDegats
if (rollData.isHeroique) { // Deux fois les dés de dégats
rollData.degatsFormula += " + " + rollData.arme.system.totalDegats
degatsMessage = "Dégats doublés"
}
}
if (rollData.typeAttaque == "precise") {
let degatsMessage = "Degats normaux"
if (rollData.isHeroique) { // Degats max
maximize = true
degatsMessage = "Dégats maximaux, ignore l'armure du défenseur"
rollData.ignoreDefenseArmor = true
}
}
if (rollData.typeAttaque == "feinte") {
degatsMessage = "Pas de dégats, mais bonus pour prochaine attaque"
rollData.degatsFormula = false
rollData.nextBonus = 5
if (rollData.isHeroique) { // Bonus pour prochaine action
rollData.nextBonus = 10
rollData.nextBonusDegats = 10
}
}
if (rollData.typeAttaque == "coupbas") {
degatsMessage = "Pas de dégats, mais malus pour prochaine action complexe du défenseur"
rollData.degatsFormula = false
rollData.nextMalus = -5
if (rollData.isHeroique) { // Malus pour prochaine action
rollData.nextMalus = -15
}
}
} else { // Armes à distance
rollData.degatsFormula = rollData.arme.system.totalDegats
if (rollData.isHeroique) { // Deux fois les dés de dégats
rollData.degatsFormula += " + " + rollData.arme.system.totalDegats
}
}
// Perform the roll, show the dice
rollData.finalResult = 0
rollData.degatsMessage = degatsMessage
if (rollData.degatsFormula) {
let degatsRoll = new Roll(rollData.degatsFormula).roll({ async: false, maximize: maximize })
await this.showDiceSoNice(degatsRoll, game.settings.get("core", "rollMode"))
rollData.degatsRoll = duplicate(degatsRoll)
rollData.finalResult = degatsRoll.total
}
this.createChatWithRollMode(rollData.alias, {
content: await renderTemplate(`systems/fvtt-mournblade/templates/chat-degats-result.html`, rollData)
}, rollData)
}
/* -------------------------------------------- */
static async bonusRollMournblade(rollData) {
rollData.bonusFormula = rollData.addedBonus
@@ -482,6 +569,7 @@ export class MournbladeUtility {
pointAmeOptions: this.getPointAmeOptions(),
difficulte: 0,
modificateur: 0,
config: game.system.mournblade.config,
}
MournbladeUtility.updateWithTarget(rollData)
return rollData
@@ -493,6 +581,7 @@ export class MournbladeUtility {
if (target) {
rollData.defenderTokenId = target.id
let defender = game.canvas.tokens.get(rollData.defenderTokenId).actor
rollData.defender = defender.toObject() // Simpler
rollData.armeDefense = defender.getBestDefenseValue()
if (rollData.armeDefense) {
rollData.difficulte = rollData.armeDefense.system.totalDefensif
@@ -655,11 +744,11 @@ export class MournbladeUtility {
/* -------------------------------------------- */
static async confirmDelete(actorSheet, li) {
let itemId = li.data("item-id");
let msgTxt = "<p>Are you sure to remove this Item ?";
let msgTxt = "<p>Voulez vous supprimer cet item ?";
let buttons = {
delete: {
icon: '<i class="fas fa-check"></i>',
label: "Yes, remove it",
label: "Oui !",
callback: () => {
actorSheet.actor.deleteEmbeddedDocuments("Item", [itemId]);
li.slideUp(200, () => actorSheet.render(false));
@@ -667,12 +756,12 @@ export class MournbladeUtility {
},
cancel: {
icon: '<i class="fas fa-times"></i>',
label: "Cancel"
label: "Non !"
}
}
msgTxt += "</p>";
let d = new Dialog({
title: "Confirm removal",
title: "Confirmer la suppression",
content: msgTxt,
buttons: buttons,
default: "cancel"