diff --git a/data/config/balance_report.yaml b/data/config/balance_report.yaml index 9f0af55..3df7743 100644 --- a/data/config/balance_report.yaml +++ b/data/config/balance_report.yaml @@ -50,6 +50,36 @@ weapons: classes: integrity_per_gauge_threshold: 3 +forge_value: + price_credit_per_level: 0.45 + weights: + - { key: damage, label: Dégâts, value: 1.0 } + - { key: damage_per_success, label: Dégâts par réussite, value: 1.8 } + - { key: rmax, label: R.Max, value: 3.0 } + - { key: precision, label: Précision, value: 1.3 } + - { key: armor_break, label: Brise-armure, value: 1.2 } + - { key: armor_pierce, label: Perce-armure, value: 2.5 } + - { key: antimaterial, label: Anti-matériel, value: 0.8 } + - { key: protection, label: Protection, value: 1.5 } + - { key: integrity, label: Intégrité, value: 0.55 } + - { key: resistance, label: Résistance, value: 1.4 } + - { key: characteristic, label: Caractéristique, value: 1.4 } + - { key: dodge_parry, label: Esquive ou parade, value: 0.8 } + - { key: speed, label: Vitesse, value: 0.25 } + - { key: stealth, label: Discrétion ou camouflage, value: 0.35 } + - { key: torque, label: Torque requis, value: 0.12 } + - { key: range, label: Portée, value: 0.1 } + - { key: alteration, label: Altération, value: 1.4 } + - { key: utility, label: Effet qualitatif, value: 1.5 } + tiers: + - { tier: 0, bonus_cap: 2.0, drawback_ratio: 0.0, expected_cost: 1.5 } + - { tier: 1, bonus_cap: 3.0, drawback_ratio: 0.0, expected_cost: 3.0 } + - { tier: 2, bonus_cap: 4.0, drawback_ratio: 0.2, expected_cost: 3.5 } + - { tier: 3, bonus_cap: 6.0, drawback_ratio: 0.35, expected_cost: 4.5 } + - { tier: 4, bonus_cap: 9.0, drawback_ratio: 0.45, expected_cost: 6.0 } + - { tier: 5, bonus_cap: 12.0, drawback_ratio: 0.4, expected_cost: 6.0 } + - { tier: 6, bonus_cap: 15.0, drawback_ratio: 0.35, expected_cost: 10.0 } + # Ordered list of report sections. Remove or comment an entry to hide it. chapters: - classes.overview @@ -73,6 +103,7 @@ chapters: - alterations.overview - craft.summary - craft.prices + - craft.forge-values - craft.elements - craft.mechanics - craft.weapons.core diff --git a/data/src/craft/forge_materials.csv b/data/src/craft/forge_materials.csv index 30cc4d0..a7cb12c 100644 --- a/data/src/craft/forge_materials.csv +++ b/data/src/craft/forge_materials.csv @@ -33,9 +33,9 @@ Termentine,4,#ddlvl(7),#ddlvl(4),Lorsque vous infligez des dégâts à une créa Pyrochite,4,#ddlvl(6),#ddlvl(4),"Votre arme inflige désormais des dégâts @el_elementaire:pl de @el_fire ; Dégâts -2, Intégrité -2",Les malus de vitesse et agilité de cet équipement sont replacés par un malus de -3 en Psyché Venturis,4,#ddlvl(6),#ddlvl(4),"Votre arme inflige désormais des dégâts @el_elementaire:pl de @el_wind ; Dégâts -1, Intégrité -2",Les malus de discretion et agilité de cet équipement sont replacés par un malus de -3 en Volonté Magozite,4,#ddlvl(7),#ddlvl(4),Transforme un type de dégat @el_elementaire simple en un autre dans les effets de vôtre arme,Pour chaque effet de matériaux ajoutant une résistance (positive ou négative) @el_elementaire simple ajoutez une résistance @el_physique de votre choix de même niveau -Razorite,4,#ddlvl(7),#ddlvl(7),Les dégats de type @el_slash sont augmentés de 4,Résistance @el_slash #resist(3) -Quakeite,4,#ddlvl(8),#ddlvl(8),"Les dégats de type @el_blunt sont augmentés de 5, @rl_arbreak +1",Résistance @el_blunt #resist(3) -Thornite,4,#ddlvl(9),#ddlvl(9),"Les dégats de type @el_pierce sont augmentés de 6, Perce Armure +1",Résistance @el_pierce #resist(3) +Razorite,4,#ddlvl(7),#ddlvl(7),"Les dégats de type @el_slash sont augmentés de 4 ; Protection -2",Résistance @el_slash #resist(3) +Quakeite,4,#ddlvl(8),#ddlvl(8),"Les dégats de type @el_blunt sont augmentés de 5, @rl_arbreak +1 ; Torque +5, Intégrité -2",Résistance @el_blunt #resist(3) +Thornite,4,#ddlvl(9),#ddlvl(9),"Les dégats de type @el_pierce sont augmentés de 6, Perce Armure +1 ; @rl_arbreak -2, Intégrité -2",Résistance @el_pierce #resist(3) Gripbane,4,#ddlvl(9),#ddlvl(5),Les jets pour @rl_arracher cette arme sont augmentés de (#ddlvl(4)) ; Intégrité -2,"A chaque fois que vous devriez subir une altération d'effet suite à la perte d'un point de fatigue, perdez la moitié de votre @rl_satiete et un point de vie sur toutes les localisation à la place ; Protection -2" Polystène,4,#ddlvl(9),#ddlvl(4),"A la fin de chaque tour, cette arme régénére un point d'intégrité tant qu'elle n'est pas intégralement détruite ; Portée -20 (si applicable), Dégâts -1","A la fin de chaque tour, cet équipement régénére un point d'intégrité tant qu'elle n'est pas intégralement détruite ; Intégrité -1, Vitesse -5" Sombraliance,5,#ddlvl(8),#ddlvl(5),"Intégrité +7, les effets des matériaux augmentant les dégâts gagnent +2 ; Torque +15 pour utiliser cette arme","Intégrité +7, les effets des matériaux augmentant la protection gagnent +2 ; Torque +15 pour utiliser cette arme" diff --git a/setup/analysis/craft_report.typ b/setup/analysis/craft_report.typ index bf5f565..b58c5b9 100644 --- a/setup/analysis/craft_report.typ +++ b/setup/analysis/craft_report.typ @@ -11,6 +11,7 @@ #import "defense_report.typ": defense-report #import "defense_metrics.typ": global-protection-efficiency-leader #import "craft_price_report.typ": craft-price-report +#import "forge_value_report.typ": forge-value-report #import "report_config.typ": chapter-enabled #let insight-card(label, value, note) = block( @@ -645,6 +646,7 @@ heading(level: 1)[Artisanat] if chapter-enabled("craft.summary") { craft-summary() } if chapter-enabled("craft.prices") { craft-price-report() } + if chapter-enabled("craft.forge-values") { forge-value-report() } if chapter-enabled("craft.battle_plan") { battle-plan() } if chapter-enabled("craft.elements") { element-coverage() } if chapter-enabled("craft.mechanics") { mechanic-analysis() } diff --git a/setup/analysis/forge_value_metrics.typ b/setup/analysis/forge_value_metrics.typ new file mode 100644 index 0000000..3fa1e47 --- /dev/null +++ b/setup/analysis/forge_value_metrics.typ @@ -0,0 +1,155 @@ +// Heuristic value audit for forge materials and finishes. +// Unknown clauses stay visible instead of receiving invented precision. +#import "report_config.typ": forge-value-settings +#import "../build_config.typ": tier-is-enabled + +#let forge-value-weights = forge-value-settings.weights +#let forge-tier-rules = forge-value-settings.tiers +#let weight(key) = forge-value-weights.find(item => item.key == key).value + +#let wrapped-number(value) = { + let found = str(value).match(regex("-?[0-9]+(?:\\.[0-9]+)?")) + if found == none { none } else { float(found.text) } +} + +#let signed-value(clause) = { + let resistance = clause.match(regex("#resist\\((-?[0-9]+)\\)")) + let difficulty = clause.match(regex("#ddlvl\\(?(?:\\s*)(-?[0-9]+)")) + let ordinary = clause.match(regex("(?:^|\\s)([+-]?[0-9]+(?:\\.[0-9]+)?)")) + if resistance != none { + float(resistance.captures.first()) + } else if difficulty != none { + float(difficulty.captures.first()) + } else if ordinary != none { + float(ordinary.captures.first()) + } else if "½" in clause { + 0.5 + } else { none } +} + +#let clause-key(clause) = { + let text = lower(clause) + if "dégât par réussite" in text or "dégats par réussite" in text { + "damage_per_success" + } else if "@rl_rmax" in text or "rmax" in text { "rmax" + } else if "perce armure" in text or "@rl_parmure" in text { "armor_pierce" + } else if "@rl_arbreak" in text or "brise armure" in text or "brise-armure" in text { "armor_break" + } else if "anti-mat" in text { "antimaterial" + } else if "précision" in text or "precision" in text { "precision" + } else if "protection" in text { "protection" + } else if "intégrité" in text or "integrite" in text or "@rl_integrite" in text { "integrity" + } else if "résistance" in text or "resistance" in text or "#resist" in text { "resistance" + } else if "esquive" in text or "parade" in text { "dodge_parry" + } else if "discretion" in text or "discrétion" in text or "camouflage" in text { "stealth" + } else if "vitesse" in text { "speed" + } else if "torque" in text { "torque" + } else if "portée" in text or "portee" in text { "range" + } else if ( + "agilité" in text or "force" in text or "volonté" in text + or "psyché" in text or "charisme" in text + ) { "characteristic" + } else if "altération" in text or "alteration" in text or "marque" in text { "alteration" + } else if "dégât" in text or "dégat" in text or "dmg" in text { "damage" + } else { none } +} + +#let qualitative-direction(clause) = { + let text = lower(clause) + let negative = ( + "perdez" in text or "subit" in text or "subissez" in text + or "malus" in text or "ne peut" in text + ) + let positive = ( + "gagne" in text or "ajoute" in text or "augmente" in text + or "diminue" in text or "réduit" in text or "dispose" in text + or "peut" in text or "régén" in text or "devient" in text + or "transforme" in text or "changez" in text or "résiste" in text + ) + if positive and not negative { 1 } else if negative and not positive { -1 } else { 0 } +} + +#let score-clause(raw) = { + let clause = raw.trim() + let key = clause-key(clause) + let value = signed-value(clause) + if key == none { + let direction = qualitative-direction(clause) + (key: "utility", raw: clause, recognized: direction != 0, signed: direction * weight("utility")) + } else if value == none { + let direction = qualitative-direction(clause) + (key: key, raw: clause, recognized: direction != 0, signed: direction * weight("utility")) + } else { + let text = lower(clause) + let explicit-drawback = ( + "votre arme subit" in text or "cet équipement subit" in text + or "cet equipement subit" in text + or ("altération" in text and "subies" in text and "augment" in text) + or ("perte" in text and "pv" in text and "augment" in text) + or ("perte" in text and "points de vie" in text and "augment" in text) + ) + let direction = if explicit-drawback { -1 + } else if ( + "diminue le malus" in text or "réduit le malus" in text + or "reduit le malus" in text + ) { 1 + } else if key == "torque" { if value < 0 { 1 } else { -1 } + } else if value < 0 { -1 } else { 1 } + (key: key, raw: clause, recognized: true, signed: direction * calc.abs(value) * weight(key)) + } +} + +#let tier-rule(tier) = forge-tier-rules.find(rule => rule.tier == tier) + +#let evaluate-forge-effect(kind, item, target, tier, cost, effect) = { + let clauses = effect.split(regex("[;,]")).map(score-clause).filter(item => item.raw != "") + let positive-values = clauses.map(item => calc.max(0, item.signed)) + let drawback-values = clauses.map(item => calc.max(0, -item.signed)) + let positive = if positive-values.len() == 0 { 0 } else { positive-values.sum() } + let drawback = if drawback-values.len() == 0 { 0 } else { drawback-values.sum() } + let rule = tier-rule(tier) + // Only the price above the normal cost of the tier buys an exception. + let excess-cost = calc.max(0, cost - rule.expected_cost) + let price-credit = excess-cost * forge-value-settings.price_credit_per_level + let effective-positive = calc.max(0, positive - price-credit) + let expected-drawback = effective-positive * rule.drawback_ratio + let flags = () + if effective-positive > rule.bonus_cap { flags.push("bonus trop élevé") } + if expected-drawback > 0 and drawback + 0.01 < expected-drawback { + flags.push("contrepartie faible") + } + if clauses.any(clause => not clause.recognized) { flags.push("lecture partielle") } + ( + kind: kind, item: item, target: target, tier: tier, cost: cost, + effect: effect, clauses: clauses, positive: positive, drawback: drawback, + net: positive - drawback, price-credit: price-credit, + effective-positive: effective-positive, expected-drawback: expected-drawback, + status: if flags.len() == 0 { "cohérent" } else { flags.join(" · ") }, + flagged: flags.len() > 0, + ) +} + +#let material-values = csv("/data/src/craft/forge_materials.csv", row-type: dictionary).map(row => { + let tier = int(wrapped-number(row.at("@ar_tier:short"))) + let cost = wrapped-number(row.at("@ar_cst:short")) + ( + evaluate-forge-effect("Matériau", row.Matériau, "Arme", tier, cost, row.at("Effets sur les Armes")), + evaluate-forge-effect("Matériau", row.Matériau, "Armure/Bouclier", tier, cost, row.at("Effet sur les Armures et Boucliers")), + ) +}).flatten().filter(item => tier-is-enabled(item.tier)) + +#let finishing-values = csv("/data/src/craft/forge_finishing.csv", row-type: dictionary).map(row => { + let tier = int(wrapped-number(row.at("@ar_tier:short"))) + evaluate-forge-effect( + "Finition", row.at("Nom de la finition"), "Selon type", tier, + wrapped-number(row.at("@ar_cst:short")), row.Effet, + ) +}).filter(item => tier-is-enabled(item.tier)) + +#let all-forge-values = material-values + finishing-values +#let forge-value-outliers = all-forge-values.filter(item => item.flagged) +#let unrecognized-forge-clauses = all-forge-values.map(item => + item.clauses.filter(clause => not clause.recognized).map(clause => ( + kind: item.kind, item: item.item, target: item.target, tier: item.tier, + clause: clause.raw, + )) +).flatten() diff --git a/setup/analysis/forge_value_report.typ b/setup/analysis/forge_value_report.typ new file mode 100644 index 0000000..83d9c3d --- /dev/null +++ b/setup/analysis/forge_value_report.typ @@ -0,0 +1,116 @@ +#import "forge_value_metrics.typ": * +#import "report_style.typ": metric-card, rounded +#import "../theme/tables.typ" as tables + +#let forge-value-report() = { + pagebreak() + heading(level: 2)[Forge — Valeur des matériaux et finitions] + [Chaque effet reçoit une valeur positive pour ses bénéfices et une valeur + négative pour ses contreparties. Seule la part du prix supérieure au coût + habituel du tier accorde un crédit de tolérance. Les limites + de tier sont volontairement souples; une lecture partielle demande un contrôle + humain plutôt qu’une conclusion automatique.] + + grid( + columns: (1fr,) * 4, + column-gutter: 8pt, + metric-card("Profils évalués", all-forge-values.len()), + metric-card("Matériaux", material-values.len()), + metric-card("Finitions", finishing-values.len()), + metric-card("À vérifier", forge-value-outliers.len()), + ) + + heading(level: 3)[Poids employés] + [Ces poids sont définis hors de l’évaluation dans `balance_report.yaml`. Une + unité indique la valeur attribuée à un point de statistique; les effets + qualitatifs utilisent une valeur forfaitaire.] + let weight-rows = forge-value-weights.map(item => ( + item.label, item.key, rounded(item.value, digits: 2), + )) + tables.set-table-style( + table( + columns: (1.2fr, 1fr, 0.45fr), + align: (left, left, right), + table.header([Statistique], [Clé], [Poids]), + ..weight-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7pt, + ) + + heading(level: 3)[Paradigme par tier] + let tier-rows = forge-tier-rules.map(rule => ( + "T" + str(rule.tier), + rounded(rule.bonus_cap, digits: 1), + str(calc.round(rule.drawback_ratio * 100)) + " %", + rounded(rule.expected_cost, digits: 1), + )) + tables.set-table-style( + table( + columns: (0.4fr, 1fr, 1fr, 0.8fr), + align: (left, right, right, right), + table.header([Tier], [Bonus après prix max.], [Contrepartie attendue], [Coût habituel]), + ..tier-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7pt, + ) + + heading(level: 3)[Profils à vérifier en priorité] + let outlier-rows = forge-value-outliers.sorted(key: item => -item.effective-positive).map(item => ( + item.kind, item.item, item.target, "T" + str(item.tier), + rounded(item.positive, digits: 1), "−" + rounded(item.drawback, digits: 1), + rounded(item.price-credit, digits: 1), item.status, + )) + if outlier-rows.len() == 0 { + [Aucun profil ne dépasse les repères configurés.] + } else { + tables.set-table-style( + table( + columns: (0.55fr, 1.25fr, 0.75fr, 0.3fr, 0.38fr, 0.38fr, 0.38fr, 1.25fr), + align: (left, left, left, center, right, right, right, left), + table.header([Type], [Objet], [Cible], [T.], [+], [−], [Prix], [Diagnostic]), + ..outlier-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 6.4pt, + ) + } + + if unrecognized-forge-clauses.len() > 0 { + heading(level: 3)[Clauses à interpréter manuellement] + [Ces clauses ne reçoivent aucune valeur inventée. Cette liste permet de + compléter progressivement les poids ou les règles de lecture.] + let clause-rows = unrecognized-forge-clauses.map(item => ( + item.kind, item.item, item.target, "T" + str(item.tier), item.clause, + )) + tables.set-table-style( + table( + columns: (0.55fr, 1.1fr, 0.75fr, 0.3fr, 2fr), + align: (left, left, left, center, left), + table.header([Type], [Objet], [Cible], [T.], [Clause non chiffrée]), + ..clause-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 6.3pt, + ) + } + + heading(level: 3)[Toutes les évaluations] + let all-rows = all-forge-values.map(item => ( + item.kind, item.item, item.target, "T" + str(item.tier), + rounded(item.positive, digits: 1), "−" + rounded(item.drawback, digits: 1), + rounded(item.net, digits: 1), rounded(item.effective-positive, digits: 1), + item.status, + )) + tables.set-table-style( + table( + columns: (0.5fr, 1.15fr, 0.72fr, 0.28fr, 0.34fr, 0.34fr, 0.38fr, 0.45fr, 1.2fr), + align: (left, left, left, center) + (right,) * 4 + (left,), + table.header([Type], [Objet], [Cible], [T.], [+], [−], [Net], [+ après prix], [Diagnostic]), + ..all-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 5.9pt, + ) +} diff --git a/setup/analysis/report_config.typ b/setup/analysis/report_config.typ index 74f4c0c..127c484 100644 --- a/setup/analysis/report_config.typ +++ b/setup/analysis/report_config.typ @@ -5,6 +5,7 @@ #let armor-settings = weapon-settings.armor #let class-weapon-settings = weapon-settings.class_weapons #let class-balance-settings = report-config.classes +#let forge-value-settings = report-config.forge_value #let enabled-report-chapters = report-config.chapters #let inclusive-range(bounds) = range(bounds.min, bounds.max + 1) @@ -57,3 +58,13 @@ 3, message: "Exactly three armor summary protections are required", ) +#assert.eq( + forge-value-settings.weights.map(item => item.key).dedup().len(), + forge-value-settings.weights.len(), + message: "Forge value weight keys must be unique", +) +#assert.eq( + forge-value-settings.tiers.map(item => item.tier).dedup().len(), + forge-value-settings.tiers.len(), + message: "Forge value tier rules must be unique", +)