public/foundryvtt-reve-de-dragon
1
1
Fork 1
Code Issues Pull Requests Actions Projects Releases 186 Wiki Activity

Amélioration de la gestion de la surprise

Browse Source
This commit is contained in:
Vincent Vandemeulebrouck
2025-09-22 16:18:29 +02:00
parent c84af21c7e
commit 74515d28f4
14 changed files with 129 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
module/rdd-combat.js
View File

@@ -567,6 +567,9 @@ export class RdDCombat {
/* -------------------------------------------- */
static isParticuliere(rollData) {
if (rollData.ids) {
return rollData.rolled.isPart
}
if (!rollData.attackerRoll && rollData.ajustements.surprise.used) {
return false;
}
@@ -575,6 +578,9 @@ export class RdDCombat {
/* -------------------------------------------- */
static isReussite(rollData) {
if (rollData.ids) {
return rollData.rolled.is
}
switch (rollData.ajustements.surprise.used) {
case 'totale': return false;
case 'demi': return rollData.rolled.isSign;
@@ -971,14 +977,14 @@ export class RdDCombat {
await RollDialog.create(rollData, {
onRoll: (dialog) => {
this._onCloseRollDialog(),
dialog.close()
dialog.close()
},
customChatMessage: true,
callbacks: [async (actor, rd) => {
this.removeChatMessageActionsPasseArme(rd.passeArme)
// defense: esquive / arme de parade / competence de défense
await rd.active.actor.incDecItemUse(rd.current[PART_DEFENSE].defense?.id, !RdDCombat.isParticuliere(rd))
if (!RdDCombat.isParticuliere(rd))
await rd.active.actor.incDecItemUse(rd.current[PART_DEFENSE].defense?.id, )
await this._onDefenseV2(rd)
}]
})

44
module/rdd-resolution-table.js
View File

@@ -184,47 +184,15 @@ export class RdDResolutionTable {
return Math.max(Math.floor(carac * (diff + 10) / 2), 1);
}
/* -------------------------------------------- */
static isEchec(rollData) {
switch (rollData.surprise) {
case 'demi': return !rollData.rolled.isSign;
case 'totale': return true;
}
return rollData.rolled.isEchec;
}
/* -------------------------------------------- */
static isEchecTotal(rollData) {
if (rollData.arme && rollData.surprise == 'demi') {
return rollData.rolled.isEchec;
}
return rollData.rolled.isETotal;
}
/* -------------------------------------------- */
static isParticuliere(rollData) {
if (rollData.arme && rollData.surprise) {
return false;
}
return rollData.rolled.isPart;
}
/* -------------------------------------------- */
static isReussite(rollData) {
switch (rollData.surprise) {
case 'demi': return rollData.rolled.isSign;
case 'totale': return false;
}
return rollData.rolled.isSuccess;
}
/* -------------------------------------------- */
static computeReussite(chances, roll, diviseur) {
const reussite = reussites.find(x => x.condition(chances, roll));
if (diviseur > 1 && reussite.code == 'norm') {
return reussiteInsuffisante;
const reussite = reussites.find(x => x.condition(chances, roll))
if (diviseur > 1 && reussite.isSuccess) {
if (chances > roll * diviseur){
return reussiteInsuffisante
}
}
return reussite;
return reussite
}
/* -------------------------------------------- */

27
module/roll/roll-basic-parts.mjs
View File

@@ -1,4 +1,8 @@
import { ActorToken } from "../actor-token.mjs"
import { StatusEffects } from "../settings/status-effects.js"
import { ROLL_MODE_ATTAQUE, ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
import { PART_ATTAQUE } from "./roll-part-attaque.mjs"
import { PART_DEFENSE } from "./roll-part-defense.mjs"
export class RollBasicParts {
@@ -11,6 +15,29 @@ export class RollBasicParts {
}
}
loadSurprises(rollData, mode) {
if (!rollData.mode.passif) {
this.loadSurprise(rollData.active, this.getForceRequiseActiveActor(rollData, mode))
this.loadSurprise(rollData.opponent, 0)
}
}
loadSurprise(who, forceRequise) {
if (who?.actor) {
foundry.utils.mergeObject(who,
StatusEffects.getActorEffetSurprise(who.actor, forceRequise),
{ overwrite: true, inPlace: true })
}
}
getForceRequiseActiveActor(rollData, mode) {
switch (mode) {
case ROLL_MODE_ATTAQUE: return rollData.current[PART_ATTAQUE].attaque.forceRequise
case ROLL_MODE_DEFENSE: return rollData.current[PART_DEFENSE].forceRequise
default: return 0
}
}
initFrom(rollData) {
return {
selected: {},

6
module/roll/roll-dialog.mjs
View File

@@ -217,7 +217,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
})
}
static async create(rollData, rollOptions = {}) {
const rollDialog = new RollDialog(rollData, rollOptions)
rollDialog.render(true)
@@ -250,9 +250,6 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
constructor(rollData, rollOptions) {
super()
this.rollData = rollData
// const callbacks = this.rollOptions.callbacks.map(c =>
// r => r.activve.actor Promise.all(this.rollOptions.callbacks.map(async callback => await callback(rollData.active.actor, rollData)))
// )
this.rollOptions = {
callbacks: [
async (actor, r) => await actor.appliquerAjoutExperience(r),
@@ -361,6 +358,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
const modes = ROLL_MODE_TABS.filter(m => m.isAllowed(rollData) && m.visible(rollData))
.map(m => m.toModeData(rollData))
BASIC_PARTS.loadSurprises(this.rollData, this.getSelectedMode().code)
this.setModeTitle()
const visibleRollParts = this.getActiveParts()

23
module/roll/roll-part-attaque.mjs
View File

@@ -41,25 +41,25 @@ export class RollPartAttaque extends RollPartSelect {
prepareContext(rollData) {
const current = this.getCurrent(rollData)
current.defenseur = StatusEffects.getActorEffetSurprise(rollData.opponent?.actor, 0)
current.attaquant = StatusEffects.getActorEffetSurprise(rollData.active.actor, current.attaque.forceRequise)
current.dmg = this.$dmgRollV2(rollData, current)
}
$dmgRollV2(rollData, current) {
const actor = rollData.active.actor
const defender = rollData.opponent?.actor
const dmgArme = RdDBonus.dmgArme(current.attaque.arme, current.attaque.dommagesArme)
const attaque = current.attaque
const arme = attaque.arme
const dmgArme = RdDBonus.dmgArme(arme, attaque.dommagesArme)
const dmg = {
total: 0,
dmgArme: dmgArme,
penetration: current.attaque.arme.penetration(),
penetration: arme.penetration(),
dmgTactique: current.tactique?.dmg ?? 0,
dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
dmgSurprise: current.surpriseDefenseur?.dmg ?? 0,
mortalite: RdDBonus.mortalite(current.dmg?.mortalite, current.attaque.arme.system.mortalite, defender?.isEntite()),
dmgActor: RdDBonus.bonusDmg(actor, current.attaque.carac.key, dmgArme, current.attaque.forceRequise),
dmgForceInsuffisante: Math.min(0, actor.getForce() - current.attaque.forceRequise)
dmgSurprise: rollData.opponent?.surprise?.dmg ?? 0,
mortalite: RdDBonus.mortalite(current.dmg?.mortalite, arme.system.mortalite, rollData.opponent?.actor?.isEntite()),
dmgActor: RdDBonus.bonusDmg(actor, attaque.carac.key, dmgArme, attaque.forceRequise),
dmgForceInsuffisante: Math.min(0, actor.getForce() - attaque.forceRequise)
}
dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere + dmg.dmgForceInsuffisante
return dmg
@@ -71,8 +71,8 @@ export class RollPartAttaque extends RollPartSelect {
if (current.tactique) {
ajustements.push({ label: current.tactique.label, diff: current.tactique.attaque })
}
if (current.surpriseDefenseur) {
ajustements.push({ label: current.surpriseDefenseur.label, diff: current.surpriseDefenseur.attaque })
if (rollData.opponent?.surprise) {
ajustements.push({ label: rollData.opponent.surprise.label, diff: rollData.opponent.surprise.attaque })
}
return ajustements
}
@@ -115,7 +115,6 @@ export class RollPartAttaque extends RollPartSelect {
switch (part.code) {
case PART_CARAC: return part.filterCaracs(rollData, [current.attaque.carac.key])
case PART_COMP: return part.filterComps(rollData, [current.attaque.comp?.name])
case PART_SIGN: return part.setArme(rollData, current.attaque.forceRequise, false)
}
}
return undefined

5
module/roll/roll-part-defense.mjs
View File

@@ -69,9 +69,6 @@ export class RollPartDefense extends RollPartSelect {
}
prepareContext(rollData) {
const current = this.getCurrent(rollData)
current.defenseur = StatusEffects.getActorEffetSurprise(rollData.active.actor, current.forceRequise)
// current.dmg = this.$dmgRollV2(rollData, current)
}
@@ -104,7 +101,7 @@ export class RollPartDefense extends RollPartSelect {
case PART_CARAC: return part.filterCaracs(rollData, [current.carac])
case PART_COMP: return part.filterComps(rollData, [current.comp?.name])
case PART_DIFF: return part.setDiff(rollData, this.getDiffDefense(rollData))
case PART_SIGN: return part.setArme(rollData, current.forceRequise, this.isArmeDisparate(rollData))
case PART_SIGN: return part.setArmeDisparate(rollData, this.isArmeDisparate(rollData))
}
}
return undefined

22
module/roll/roll-part-sign.mjs
View File

@@ -39,8 +39,7 @@ export class RollPartSign extends RollPart {
const isCombat = this.isCombat(rollData)
const current = this.getCurrent(rollData)
current.armeDisparate = isCombat && current.armeDisparate
current.forceRequise = current.forceRequise ?? 0
current.surprise = actor.getSurprise(isCombat)
current.surprise = actor.getSurprise(isCombat) // TODO: could be from rollData.active.surprise??
current.reasons = actor.getEffects(it => StatusEffects.niveauSurprise(it) > 0).map(it => it.name)
current.diviseur = 1
if (current.surprise == 'demi') {
@@ -53,10 +52,6 @@ export class RollPartSign extends RollPart {
current.diviseur *= 2
current.reasons.push('Armes disparates')
}
if (this.isForceInsuffisante(actor, current)) {
current.diviseur *= 2
current.reasons.push('Force insuffisante')
}
if (this.isAttaqueFinesse(rollData)) {
current.diviseur *= 2
current.reasons.push('Particulière en finesse')
@@ -73,15 +68,6 @@ export class RollPartSign extends RollPart {
return ROLL_MODE_DEFENSE == rollData.mode.current && rollData.attaque.particuliere == 'finesse'
}
isForceInsuffisante(actor, current) {
if (actor?.isPersonnage()) {
const requise = current.forceRequise
const force = parseInt(actor.system.carac.force.value)
return requise > force
}
return false
}
isParadeArmeDisparate(current) {
return current.armeDisparate
}
@@ -106,9 +92,7 @@ export class RollPartSign extends RollPart {
})
}
setArme(rollData, forceRequise, armeDisparate) {
const current = this.getCurrent(rollData)
current.armeDisparate = armeDisparate
current.forceRequise = forceRequise
setArmeDisparate(rollData, armeDisparate) {
this.getCurrent(rollData).armeDisparate = armeDisparate
}
}