diff --git a/balance_report.typ b/balance_report.typ index 39008a4..fdf4a45 100644 --- a/balance_report.typ +++ b/balance_report.typ @@ -3,10 +3,20 @@ #import "/setup/analysis/class_cost_report.typ": render-class-cost-report #import "/setup/analysis/origin_report.typ": render-origin-report #import "/setup/analysis/craft_report.typ": render-craft-report +#import "/setup/analysis/report_config.typ": chapter-family-enabled #let report-theme = themes.make-theme(theme-name: "steingrund") #let report-theme-var = themes.make-theme-variable(theme-name: "steingrund") +#let report-numbering(..numbers) = { + let patterns = ("1", "1", "1", "I", "a") + numbers.pos().enumerate().map(pair => { + let index = pair.at(0) + let number = pair.at(1) + numbering(patterns.at(index, default: "1"), number) + }).join([.]) + [.] +} + #let configure-report(document) = { set page( paper: "a4", @@ -20,7 +30,7 @@ fill: report-theme.ink, ) set par(justify: true, leading: 0.65em, spacing: 0.75em) - set heading(numbering: "1.1.a.") + set heading(numbering: report-numbering) let heading-label(it) = if it.numbering == none { [] } else { counter(heading).display(it.numbering) @@ -74,8 +84,8 @@ #pagebreak() -#render-class-cost-report() +#if chapter-family-enabled("classes") { render-class-cost-report() } -#render-origin-report() +#if chapter-family-enabled("origins") { render-origin-report() } -#render-craft-report() +#if chapter-family-enabled("craft") { render-craft-report() } diff --git a/chapters/creation.typ b/chapters/creation.typ index 53131c9..24adafa 100644 --- a/chapters/creation.typ +++ b/chapters/creation.typ @@ -82,7 +82,7 @@ Bien que rarement utilisés par les chasseurs, ces deux caractéristiques sont e === Choix des armes et des consommables -L'arme de l'école choisie et une armure possible à équiper sont en général fournies lors de la création de personnage. Selon l'expérience et l'ancienneté de ces derniers, leurs armes et armures pourront posséder jusqu'à 10#ddlvl(1) de modifications chacune; et un certain nombre de consommables sauront aussi fournis à hauteur de 6#ddlvl(1) à 15#ddlvl(1) de rareté. +L'arme de l'école choisie et une armure possible à équiper sont en général fournies lors de la création de personnage. Selon l'expérience et l'ancienneté de ces derniers, leurs armes et armures pourront posséder jusqu'à #ddlvl(10) de modifications chacune; et un certain nombre de consommables sauront aussi fournis à hauteur de #ddlvl(6) à #ddlvl(15) de rareté. Ce choix reste entièrement dépendant du scénario et du @maitredejeu, qui peut souhaiter faire commencer la partie après une cuisante défaite ayant détruit tout le matériel des chasseurs ou la veille d'une grande bataille où tous les équipements seraient fournis pour la mission (bien que cela soit excessivement rarement le cas). diff --git a/data/config/balance_report.yaml b/data/config/balance_report.yaml new file mode 100644 index 0000000..52de15f --- /dev/null +++ b/data/config/balance_report.yaml @@ -0,0 +1,63 @@ +# Central configuration for the standalone balancing report. +# Ranges use inclusive `min` and `max` values. + +build: + max_tier_exclusive: 5 + +weapons: + natural_precision: 7 + die_sides: 10 + action_budget: 2 + + damage_scenarios: + - key: low + label: Faible + dice: 5 + - key: mid + label: Moyen + dice: 8 + - key: full + label: Total + dice: 14 + + sensitivity: + base_precision: + min: 2 + max: 8 + dice: + min: 3 + max: 14 + comparison_dice: [5, 8, 14] + breakpoint_method: normalized_knee + + armor: + protection: + min: 5 + max: 15 + protection_between_attacks: static + breakpoint_method: largest_marginal_drop + summary_protections: [5, 10, 15] + utilization_protection: 10 + utilization_dice: 8 + +# Ordered list of report sections. Remove or comment an entry to hide it. +chapters: + - classes.overview + - classes.tiers + - classes.alterations + - classes.details + - origins.summary + - origins.characteristics + - origins.abilities + - origins.resistances + - origins.gauge + - origins.passives + - craft.summary + - craft.elements + - craft.mechanics + - craft.weapons.core + - craft.defenses + - craft.weapons.sensitivity + - craft.weapons.armor + - craft.battle_plan + - craft.audit diff --git a/data/src/craft/alchemy_solvants.csv b/data/src/craft/alchemy_solvants.csv index e923207..25396b7 100644 --- a/data/src/craft/alchemy_solvants.csv +++ b/data/src/craft/alchemy_solvants.csv @@ -8,11 +8,11 @@ Graisse de Zizfir (Yenuï),2,#ddlvl(3),#ddlvl(1),#ddlvl(0),"Vous pouvez prendre Larmes d'Ulcen Clairvoyant (Célestial),3,#ddlvl(4),"#ddlvl(-2)",#ddlvl(0),Diminuez la difficulté de la recette Sang de Vathaknor (Yenuï),3,#ddlvl(2),#ddlvl(2),#ddlvl(0),Augmente les dégâts élémentaires de votre potion de 4 Lymphe de Dremaë Mantelaube (Célestial),3,#ddlvl(0),#ddlvl(4),#ddlvl(0),Vous pouvez choisir un ingrédient d'un tiers supérieur au vôtre -Venin de Herkan Noir (Djieien),3,#ddlvl(3),6#ddlvl(1),7#ddlvl(1),Augmente les dégâts des éléments de couleur Abyssale de votre potion de 4d6 -Sang d'Yggradren Vertueux (Abyssal),3,#ddlvl(2),5#ddlvl(1),#ddlvl(1),Diminue de moitié les effets [marqués] de la recette -Bile de Clémar irritable (Dragon),4,#ddlvl(3),7#ddlvl(1),#ddlvl(3),Augmente les dégâts des éléments de couleur Céleste de votre potion de 1d6 et son rayon d'action de +2d10 métres -Lymphe d'Arjatayu (Röc),4,#ddlvl(3),6#ddlvl(1),#ddlvl(2),Donne deux points de brise-armure aux dégâts élémentaires de votre potion +Venin de Herkan Noir (Djieien),3,#ddlvl(3),#ddlvl(6),#ddlvl(7),Augmente les dégâts des éléments de couleur Abyssale de votre potion de 4d6 +Sang d'Yggradren Vertueux (Abyssal),3,#ddlvl(2),#ddlvl(5),#ddlvl(1),Diminue de moitié les effets [marqués] de la recette +Bile de Clémar irritable (Dragon),4,#ddlvl(3),#ddlvl(7),#ddlvl(3),Augmente les dégâts des éléments de couleur Céleste de votre potion de 1d6 et son rayon d'action de +2d10 métres +Lymphe d'Arjatayu (Röc),4,#ddlvl(3),#ddlvl(6),#ddlvl(2),Donne deux points de brise-armure aux dégâts élémentaires de votre potion Sang de Karvadon Aveugle (Béhémoth),4,#ddlvl(2),#ddlvl(2),#ddlvl(1),Vous pouvez prendre jusqu'à trois ingrédients alchémiques pour votre potion -Huile de Pyraxen des profondeurs (Léviathen),4,#ddlvl(3),7#ddlvl(1),#ddlvl(2),Supprime les effets [marqués] de la recette -Sépia d'Hodrevyr Astucieux (Kraken),5,9#ddlvl(1),5#ddlvl(1),#ddlvl(3),Les dégâts subis par les marques de @al_poison:pl sont augmentés de un (ne cumule pas) (#ddlvl(3)) -Sang de Skavaranth Scorique (Dragon),5,#ddlvl(3),6#ddlvl(1),#ddlvl(4),Augmente les dégâts de @el_magma de la potion 5d10 +Huile de Pyraxen des profondeurs (Léviathen),4,#ddlvl(3),#ddlvl(7),#ddlvl(2),Supprime les effets [marqués] de la recette +Sépia d'Hodrevyr Astucieux (Kraken),5,#ddlvl(9),#ddlvl(5),#ddlvl(3),Les dégâts subis par les marques de @al_poison:pl sont augmentés de un (ne cumule pas) (#ddlvl(3)) +Sang de Skavaranth Scorique (Dragon),5,#ddlvl(3),#ddlvl(6),#ddlvl(4),Augmente les dégâts de @el_magma de la potion 5d10 diff --git a/data/src/craft/restoration_sides.csv b/data/src/craft/restoration_sides.csv index 6cdc4b5..a257ee0 100644 --- a/data/src/craft/restoration_sides.csv +++ b/data/src/craft/restoration_sides.csv @@ -2,9 +2,9 @@ Accompagnement,@ar_tier,@ar_cst,@ar_lvl,@ar_tox,@rl_satiete,Effet Perkol (Courges),0,#ddlvl(0),#ddlvl(1),#ddlvl(-3),#ddlvl(2),Diminue la toxicité de la recette Biadok (Navets),0,#ddlvl(0),#ddlvl(1),#ddlvl(0),#ddlvl(1),Gagne deux points de \jtox maximum temporaire Bluk'ta (Oigonos),1,#ddlvl(0),#ddlvl(-4),#ddlvl(0),#ddlvl(1),Diminue la difficulté de la recette -Antaris (Riz),2,#ddlvl(1),#ddlvl(2),ddlvl(-4),#ddlvl(3),Diminue la toxicité de la recette +Antaris (Riz),2,#ddlvl(1),#ddlvl(2),#ddlvl(-4),#ddlvl(3),Diminue la toxicité de la recette Vegilous (Tomates),2,#ddlvl(1),#ddlvl(4),#ddlvl(0),#ddlvl(1),Diminue de un point les effets [marqués] de la recette -Tiblin (Potirons),3,#ddlvl(1),\ddmod-51,#ddlvl(0),#ddlvl(2),Diminue la difficulté de la recette +Tiblin (Potirons),3,#ddlvl(1),#ddlvl(-5),#ddlvl(0),#ddlvl(2),Diminue la difficulté de la recette Ardanta (Racine),3,#ddlvl(1),#ddlvl(3),#ddlvl(0),#ddlvl(3),Gagne cinq points de \jtox maximum temporaire Taltos (Patates),3,#ddlvl(1),#ddlvl(4),#ddlvl(2),#ddlvl(1),Augmente une valeur de résistance des effets de la recette (#ddlvl(2)) ou #resist(1) Cerfa (Carottes),3,#ddlvl(2),#ddlvl(5),#ddlvl(0),#ddlvl(1),Diminue de moitié les effets [marqués] de la recette diff --git a/data/src/glossaries/elements.yml b/data/src/glossaries/elements.yml index 1e118dc..c171d8e 100644 --- a/data/src/glossaries/elements.yml +++ b/data/src/glossaries/elements.yml @@ -4,7 +4,7 @@ custom: icon: true short: - typst: 'box(height: 0.65em, baseline: 0.5pt, inset: 0pt, image("/images/icons/slash.png"))' + typst: 'box(height: 0.65em, baseline: 0.5pt, inset: 0pt, image("/images/icons/slash.svg"))' long: Tranchant description: "Type de dégât physique décrivant les attaques portées avec des objets acérés visant à couper leur cible." group: Dégâts physiques @@ -13,7 +13,7 @@ custom: icon: true short: - typst: 'box(height: 0.7em, baseline: 0.7pt, inset: 0pt, image("/images/icons/pierce.png"))' + typst: 'box(height: 0.7em, baseline: 0.7pt, inset: 0pt, image("/images/icons/pierce.svg"))' long: Perçant description: "Type de dégât physique décrivant les attaques portées avec des objets pointus cherchant à pénétrer les défences de leur cible." group: Dégâts physiques @@ -130,7 +130,7 @@ custom: icon: true short: - typst: 'box(height: 0.75em, baseline: 1.1pt, inset: 0pt, image("/images/icons/existence.png"))' + typst: 'box(height: 0.75em, baseline: 1.1pt, inset: 0pt, image("/images/icons/existence.svg"))' long: Existence description: > Dégâts absolus, ces dégâts ignorent toute forme de résistance, ces attaques ne peuvent être parées ou esquivées diff --git a/images/icons/blood.png b/images/icons/blood.png deleted file mode 100644 index 401724a..0000000 Binary files a/images/icons/blood.png and /dev/null differ diff --git a/images/icons/blood.svg b/images/icons/blood.svg index d72e491..07adf82 100644 --- a/images/icons/blood.svg +++ b/images/icons/blood.svg @@ -6,7 +6,7 @@ preserveAspectRatio="xMidYMid meet"> +fill="#ea1223" stroke="none"> +fill="#dcab35" stroke="none"> +fill="#1d592e" stroke="none"> - - \ No newline at end of file + + + + + + + + + + + + diff --git a/images/icons/protection.png b/images/icons/protection.png deleted file mode 100644 index ce4638b..0000000 Binary files a/images/icons/protection.png and /dev/null differ diff --git a/images/icons/protection.svg b/images/icons/protection.svg index f8b5c1f..300a541 100644 --- a/images/icons/protection.svg +++ b/images/icons/protection.svg @@ -6,7 +6,7 @@ preserveAspectRatio="xMidYMid meet"> +fill="#1f5394" stroke="none"> (mention.craft, mention.dataset, mention.item, if mention.tier == none { [—] } else { mention.tier }, mention.role, mention.element, mention.raw)) tables.set-table-style(table(columns: (0.62fr, 0.7fr, 1.15fr, 0.25fr, 0.55fr, 0.58fr, 1.85fr), @@ -316,9 +334,13 @@ #let render-craft-report() = { pagebreak() heading(level: 1)[Artisanat] - craft-summary() - element-coverage() - mechanic-analysis() - battle-plan() - craft-audit() + if chapter-enabled("craft.summary") { craft-summary() } + if chapter-enabled("craft.battle_plan") { battle-plan() } + if chapter-enabled("craft.elements") { element-coverage() } + if chapter-enabled("craft.mechanics") { mechanic-analysis() } + if chapter-enabled("craft.weapons.core") { weapon-analysis-report() } + if chapter-enabled("craft.weapons.sensitivity") { weapon-breakpoint-report() } + if chapter-enabled("craft.weapons.armor") { weapon-armor-report() } + if chapter-enabled("craft.defenses") { defense-report() } + if chapter-enabled("craft.audit") { craft-audit() } } diff --git a/setup/analysis/defense_metrics.typ b/setup/analysis/defense_metrics.typ new file mode 100644 index 0000000..242d38d --- /dev/null +++ b/setup/analysis/defense_metrics.typ @@ -0,0 +1,60 @@ +// Compact defensive-equipment metrics derived from forge compositions. +#import "../../chapters/craft/forge-data.typ": equipments + +#let defense-category-labels = (Armors: "Armure", Shields: "Bouclier") +#let defense-nature-labels = ( + Light: "Léger", Medium: "Moyen", Heavy: "Lourd", SuperHeavy: "Super-lourd", +) + +#let minimum-torque(item) = { + let available = (item.torque_one_handed, item.torque_two_handed).filter(value => value != none) + if available.len() == 0 { none } else { calc.min(..available) } +} + +#let defensive-equipment = equipments.filter(item => ( + item.apply_category in ("Armors", "Shields") +)).map(item => ( + name: defense-category-labels.at(item.apply_category) + " · " + + defense-nature-labels.at(item.nature_category), + category: item.apply_category, + category-label: defense-category-labels.at(item.apply_category), + nature: item.nature_category, + nature-label: defense-nature-labels.at(item.nature_category), + protection: item.protection, + integrity: item.integrity, + parry: item.parry, + torque-one: item.torque_one_handed, + torque-two: item.torque_two_handed, + torque: minimum-torque(item), + source: item, +)) + +#let all-equipment-efficiency = equipments.filter(item => ( + item.apply_category in ("Weapons", "Armors", "Shields") +)).map(item => ( + name: item.name, + category: item.apply_category, + protection: item.protection, + torque: minimum-torque(item), +)).filter(item => item.torque != none and item.torque > 0) + +#let defense-leader(key, filter: item => true) = defensive-equipment.filter(filter).sorted( + key: item => if key == "torque" { item.at(key) } else { -item.at(key) }, +).first() + +#let protection-leader = defense-leader("protection") +#let integrity-leader = defense-leader("integrity") +#let parry-leader = defense-leader("parry") +#let torque-leader = defense-leader("torque") + +#let defense-efficiency(item, key) = if item.torque == 0 { 0 } else { + item.at(key) / item.torque +} + +#let protection-efficiency-leader = defensive-equipment.sorted( + key: item => -defense-efficiency(item, "protection"), +).first() + +#let global-protection-efficiency-leader = all-equipment-efficiency.sorted( + key: item => -(item.protection / item.torque), +).first() diff --git a/setup/analysis/defense_report.typ b/setup/analysis/defense_report.typ new file mode 100644 index 0000000..e1b6c3a --- /dev/null +++ b/setup/analysis/defense_report.typ @@ -0,0 +1,62 @@ +// Concise armor and shield comparison for the balance report. +#import "@preview/primaviz:0.6.0": line-chart +#import "defense_metrics.typ": * +#import "report_style.typ": chart-theme +#import "../theme/tables.typ" as tables + +#let defense-report() = { + pagebreak() + heading(level: 2)[Artisanat — Armures et boucliers] + [La torque est traitée comme la contrainte; protection, intégrité et parade + comme des bénéfices indépendants. Pour comparer les équipements, `Torque min.` + retient la plus faible prise valide. Les deux prises restent visibles dans le + tableau afin de ne pas masquer les contraintes d’équipement.] + + heading(level: 3)[Protection face à la torque] + grid( + columns: (1fr, 1fr), + column-gutter: 12pt, + ..("Armors", "Shields").map(category => { + let items = defensive-equipment.filter(item => item.category == category) + line-chart( + ( + labels: items.map(item => [T#item.torque]), + values: items.map(item => item.protection), + ), + width: 100%, + height: 180pt, + title: [#defense-category-labels.at(category)], + show-points: true, + line-width: 1.4pt, + point-size: 5pt, + x-label: [Torque minimale], + y-label: [Protection], + theme: chart-theme, + ) + }), + ) + + heading(level: 3)[Tableau défensif] + let rows = defensive-equipment.map(item => ( + item.name, + str(item.protection), + str(item.integrity), + if item.parry > 0 { "+" + str(item.parry) } else { str(item.parry) }, + if item.torque-one == none { [—] } else { str(item.torque-one) }, + if item.torque-two == none { [—] } else { str(item.torque-two) }, + str(item.torque), + )) + tables.set-table-style( + table( + columns: (1.5fr, 0.72fr, 0.72fr, 0.65fr, 0.72fr, 0.72fr, 0.78fr), + align: (left,) + (right,) * 6, + table.header( + [Équipement], [Protection], [Intégrité], [Parade], + [Torque 1M], [Torque 2M], [Torque min.], + ), + ..rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) +} diff --git a/setup/analysis/origin_report.typ b/setup/analysis/origin_report.typ index ba8fb9d..afff7fa 100644 --- a/setup/analysis/origin_report.typ +++ b/setup/analysis/origin_report.typ @@ -4,6 +4,7 @@ #import "origin_metrics.typ": * #import "report_style.typ": chart-theme, metric-card, report-theme, rounded #import "../theme/tables.typ" as tables +#import "report_config.typ": chapter-enabled #let dictionary-chart(data, title, height: 165pt) = horizontal-bar-chart( ( @@ -23,7 +24,7 @@ let seven = characteristic-counts(origins: origins, value: 7) let five = characteristic-counts(origins: origins, value: 5) - heading(level: 2)[Origines — synthèse] + heading(level: 2)[Origines — Synthèse] grid( columns: (1fr, 1fr, 1fr, 1fr), @@ -99,7 +100,7 @@ } #let characteristic-audit(origins: all-origin-metrics) = { - heading(level: 2)[Origines — détail des caractéristiques] + heading(level: 2)[Origines — Détail des caractéristiques] let rows = () for origin in origins { rows.push(( @@ -150,7 +151,7 @@ #let ability-audit(origins: all-origin-metrics) = { pagebreak(weak: true) - heading(level: 2)[Origines — capacités par famille] + heading(level: 2)[Origines — Capacités par famille] let families = abilities-by-family(origins: origins) grouped-bar-chart( @@ -185,7 +186,7 @@ #let resistance-audit(origins: all-origin-metrics) = { pagebreak(weak: true) - heading(level: 2)[Origines — audit des résistances] + heading(level: 2)[Origines — Audit des résistances] [Cette extraction est heuristique. Elle analyse uniquement les descriptions de capacités `passive` et retient les segments contenant « résistance » ou @@ -214,7 +215,7 @@ #let passive-bonus-detail(origins: all-origin-metrics) = { pagebreak() - heading(level: 2)[Origines — gains numériques des passifs] + heading(level: 2)[Origines — Gains numériques des passifs] [L’extraction retient uniquement les bonus numériques explicites séparés par des virgules. Elle distingue Jauge, Initiative, mobilité, Fatigue, PV et @@ -261,7 +262,7 @@ ) pagebreak() - heading(level: 2)[Origines — audit des gains passifs] + heading(level: 2)[Origines — Audit des gains passifs] let audit-rows = grants.map(grant => ( grant.family, @@ -287,7 +288,7 @@ #let jauge-focus(origins: all-origin-metrics) = { pagebreak() - heading(level: 2)[Origines — focus Jauge] + heading(level: 2)[Origines — Focus Jauge] let grants = all-passive-bonuses(origins: origins).filter( grant => grant.category == "Jauge", @@ -360,11 +361,13 @@ #let render-origin-report(origins: all-origin-metrics) = { pagebreak() heading(level: 1)[Origines] - origin-summary(origins: origins) - pagebreak() - characteristic-audit(origins: origins) - ability-audit(origins: origins) - resistance-audit(origins: origins) - jauge-focus(origins: origins) - passive-bonus-detail(origins: origins) + if chapter-enabled("origins.summary") { origin-summary(origins: origins) } + if chapter-enabled("origins.characteristics") { + pagebreak() + characteristic-audit(origins: origins) + } + if chapter-enabled("origins.abilities") { ability-audit(origins: origins) } + if chapter-enabled("origins.resistances") { resistance-audit(origins: origins) } + if chapter-enabled("origins.gauge") { jauge-focus(origins: origins) } + if chapter-enabled("origins.passives") { passive-bonus-detail(origins: origins) } } diff --git a/setup/analysis/report_config.typ b/setup/analysis/report_config.typ new file mode 100644 index 0000000..9719c56 --- /dev/null +++ b/setup/analysis/report_config.typ @@ -0,0 +1,49 @@ +// Typed accessors and validation for the balance-report YAML configuration. +#let report-config = yaml("/data/config/balance_report.yaml") +#let build-settings = report-config.build +#let weapon-settings = report-config.weapons +#let sensitivity-settings = weapon-settings.sensitivity +#let armor-settings = weapon-settings.armor +#let enabled-report-chapters = report-config.chapters + +#let inclusive-range(bounds) = range(bounds.min, bounds.max + 1) + +#let chapter-enabled(id) = id in enabled-report-chapters +#let chapter-family-enabled(family) = enabled-report-chapters.any(id => ( + id.split(".").first() == family +)) + +#assert(weapon-settings.die_sides > 0, message: "weapons.die_sides must be positive") +#assert(weapon-settings.action_budget == 2, message: "Only a 2-action analysis budget is currently supported") +#assert(weapon-settings.damage_scenarios.len() > 0, message: "At least one damage scenario is required") +#assert.eq( + weapon-settings.damage_scenarios.map(item => item.key).dedup().len(), + weapon-settings.damage_scenarios.len(), + message: "Damage scenario keys must be unique", +) +#for required-key in ("low", "mid", "full") { + assert( + required-key in weapon-settings.damage_scenarios.map(item => item.key), + message: "Missing required damage scenario: " + required-key, + ) +} +#assert.eq( + sensitivity-settings.breakpoint_method, + "normalized_knee", + message: "Unsupported weapon sensitivity breakpoint method", +) +#assert.eq( + armor-settings.breakpoint_method, + "largest_marginal_drop", + message: "Unsupported armor breakpoint method", +) +#assert.eq( + armor-settings.protection_between_attacks, + "static", + message: "Only static protection between attacks is currently supported", +) +#assert.eq( + armor-settings.summary_protections.len(), + 3, + message: "Exactly three armor summary protections are required", +) diff --git a/setup/analysis/weapon_armor_breakpoints.typ b/setup/analysis/weapon_armor_breakpoints.typ new file mode 100644 index 0000000..c504a8e --- /dev/null +++ b/setup/analysis/weapon_armor_breakpoints.typ @@ -0,0 +1,117 @@ +// Exact probabilistic armor-destruction model for generated weapons. +#import "weapon_metrics.typ": * +#import "weapon_breakpoints.typ": comparison-dice-pools, mean, numeric-median +#import "report_config.typ": armor-settings, inclusive-range + +#let analyzed-protections = inclusive-range(armor-settings.protection) + +#let armor-destroyed(damage, protection, armor-break) = ( + calc.min(armor-break, calc.max(0, damage - protection)) +) + +#let expected-attack-armor-destruction(item, dice, protection) = { + let probability = item.success-probability + range(0, dice + 1).map(successes => { + let damage = damage-at-successes( + item.base-damage, + item.p-damage, + calc.min(successes, item.rmax), + ) + ( + binomial-probability(dice, successes, probability) + * armor-destroyed(damage, protection, item.armor-break) + ) + }).sum() +} + +#let armor-commitment-analysis(item, dice, protection) = { + let single = expected-attack-armor-destruction(item, dice, protection) + let candidates = if item.actions == 1 and dice >= 2 { + range(1, calc.floor(dice / 2) + 1).map(first => ( + first: first, + second: dice - first, + destruction: expected-attack-armor-destruction(item, first, protection) + + expected-attack-armor-destruction(item, dice - first, protection), + )) + } else { + () + } + let best-split = if candidates.len() == 0 { none } else { + candidates.sorted(key: candidate => -candidate.destruction).first() + } + let use-split = best-split != none and best-split.destruction > single + ( + destruction: if use-split { best-split.destruction } else { single }, + attacks: if use-split { 2 } else { 1 }, + strategy: if use-split { + str(best-split.first) + "+" + str(best-split.second) + } else { + str(dice) + }, + ) +} + +#let armor-destruction-grid(dice) = all-weapon-metrics.map(item => ( + analyzed-protections.map(protection => ( + armor-commitment-analysis(item, dice, protection).destruction + )) +)) + +#let armor-utilization-grid(dice) = all-weapon-metrics.map(item => ( + analyzed-protections.map(protection => { + let result = armor-commitment-analysis(item, dice, protection) + let capacity = item.armor-break * result.attacks + if capacity == 0 { 0 } else { result.destruction / capacity * 100 } + }) +)) + +#let armor-protection-breakpoint(item, dice) = { + if item.armor-break == 0 { return none } + let values = analyzed-protections.map(protection => ( + armor-commitment-analysis(item, dice, protection).destruction + )) + let drops = range(1, analyzed-protections.len()).map(index => ( + protection: analyzed-protections.at(index), + drop: values.at(index - 1) - values.at(index), + )) + let strongest = drops.sorted(key: point => -point.drop).first() + if strongest.drop <= 0.000001 { none } else { strongest } +} + +#let armor-breakpoint-table = all-weapon-metrics.map(item => ( + weapon: item.name, + points: comparison-dice-pools.map(dice => armor-protection-breakpoint(item, dice)), +)) + +#let armor-summary = comparison-dice-pools.map(dice => { + let at(protection) = mean(all-weapon-metrics.map(item => ( + armor-commitment-analysis(item, dice, protection).destruction + ))) + let utilization-protection = armor-settings.utilization_protection + let utilization = mean(all-weapon-metrics.filter(item => ( + item.armor-break > 0 + )).map(item => { + let result = armor-commitment-analysis(item, dice, utilization-protection) + result.destruction / (item.armor-break * result.attacks) * 100 + })) + let valid-breakpoints = all-weapon-metrics.map(item => ( + armor-protection-breakpoint(item, dice) + )).filter(point => point != none) + ( + dice: dice, + benchmark-values: armor-settings.summary_protections.map(at), + utilization-protection-damage: at(utilization-protection), + utilization: utilization, + median-breakpoint: numeric-median(valid-breakpoints.map(point => point.protection)), + ) +}) + +#let nature-armor-series(dice) = weapon-natures.map(nature => ( + name: weapon-nature-labels.at(nature), + points: analyzed-protections.map(protection => ( + protection, + mean(all-weapon-metrics.filter(item => item.nature-key == nature).map(item => ( + armor-commitment-analysis(item, dice, protection).destruction + ))), + )), +)) diff --git a/setup/analysis/weapon_armor_report.typ b/setup/analysis/weapon_armor_report.typ new file mode 100644 index 0000000..33f8504 --- /dev/null +++ b/setup/analysis/weapon_armor_report.typ @@ -0,0 +1,148 @@ +// Report views for exact armor-destruction expectations and breakpoints. +#import "@preview/primaviz:0.6.0": heatmap, multi-line-chart +#import "weapon_armor_breakpoints.typ": * +#import "report_style.typ": chart-theme, rounded +#import "../theme/tables.typ" as tables +#import "../theme/themes.typ": make-theme + +#let report-theme = make-theme(theme-name: "steingrund") +#let armor-palette = ( + report-theme.at("chart-4"), + report-theme.at("chart-3"), + report-theme.at("chart-2"), + report-theme.at("parchment-light"), +) +#let shape-short = ( + "Griffes": "Grif.", "Hast": "Hast", "Épée": "Épée", + "Marteau": "Mart.", "Hache": "Hache", "Arbalète": "Arba.", "Arc": "Arc", +) +#let nature-short = (Light: "L", Medium: "M", Heavy: "Ld", SuperHeavy: "SL") +#let weapon-labels = all-weapon-metrics.map(item => [ + #shape-short.at(item.shape) · #nature-short.at(item.nature-key) +]) + +#let weapon-armor-report() = { + pagebreak() + heading(level: 3)[Franchissement et destruction d’armure] + [Une attaque qui inflige $D$ dégâts contre une protection $P$ détruit + `min(Brise-armure, max(0, D − P))` points d’armure. Les résultats ci-dessous + intègrent toute la distribution binomiale. Les armes à 1A testent tous les + partages légaux sur 2A et retiennent celui qui maximise la destruction; la + protection reste un seuil de référence constant entre les deux attaques.] + + let summary-rows = armor-summary.map(row => ( + str(row.dice), + ..row.benchmark-values.map(value => rounded(value, digits: 2)), + rounded(row.utilization, digits: 1) + [%], + rounded(row.at("median-breakpoint"), digits: 1), + )) + tables.set-table-style( + table( + columns: (0.55fr, 0.9fr, 0.9fr, 0.9fr, 1.15fr, 1.15fr), + align: (right,) * 6, + table.header( + [Pool], + ..armor-settings.summary_protections.map(protection => [Armure détr. P#protection]), + [Capacité à P#armor-settings.utilization_protection], + [Rupture médiane], + ), + ..summary-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) + + let first = armor-summary.first() + let last = armor-summary.last() + let evolution(start, end) = if start == 0 { 0 } else { (end / start - 1) * 100 } + [*Conclusion calculée.* Entre #first.dice et #last.dice dés, la destruction + moyenne contre P#armor-settings.utilization_protection passe de + #rounded(first.utilization-protection-damage, digits: 2) à + #rounded(last.utilization-protection-damage, digits: 2) + (#rounded(evolution(first.utilization-protection-damage, last.utilization-protection-damage), digits: 1)%). + La rupture médiane se déplace de P#rounded(first.at("median-breakpoint"), digits: 1) + à P#rounded(last.at("median-breakpoint"), digits: 1).] + + heading(level: 4)[Courbes de résistance par poids] + grid( + columns: (1fr, 1fr, 1fr), + column-gutter: 8pt, + ..comparison-dice-pools.map(dice => multi-line-chart( + ( + labels: analyzed-protections.map(str), + series: nature-armor-series(dice).map(series => ( + name: series.name, + values: series.points.map(point => point.at(1)), + )), + ), + width: 100%, + height: 180pt, + title: [#dice dés], + show-points: true, + line-width: 1.2pt, + point-size: 4pt, + x-label: [Protection], + y-label: [Armure détruite], + theme: chart-theme, + )), + ) + + heading(level: 4)[Destruction attendue par arme] + for dice in comparison-dice-pools { + block(breakable: false)[ + #heading(level: 5)[#dice dés] + #align(center, heatmap( + ( + rows: weapon-labels, + cols: analyzed-protections.map(value => [P#value]), + values: armor-destruction-grid(dice), + ), + cell-size: 17pt, + show-values: true, + palette: armor-palette, + theme: chart-theme, + )) + ] + } + + heading(level: 4)[Rendement de la capacité de brise-armure] + [Cette carte normalise la destruction attendue par la capacité maximale de + brise-armure disponible sur les attaques retenues. Elle distingue une grande + statistique théorique d’une statistique effectivement exploitable.] + block(breakable: false)[ + #heading(level: 5)[Utilisation à #armor-settings.utilization_dice dés (%) ] + #align(center, heatmap( + ( + rows: weapon-labels, + cols: analyzed-protections.map(value => [P#value]), + values: armor-utilization-grid(armor-settings.utilization_dice), + ), + cell-size: 17pt, + show-values: true, + palette: armor-palette, + theme: chart-theme, + )) + ] + + heading(level: 4)[Points de rupture par arme] + [La rupture est le passage de protection qui provoque la plus forte perte + marginale de destruction attendue; aucun seuil de pourcentage n’est imposé.] + let breakpoint-rows = armor-breakpoint-table.map(row => ( + row.weapon, + ..row.points.map(point => ( + if point == none { [Inopérant] } else { + [P#point.protection · −#rounded(point.drop, digits: 2)] + }, + )), + )) + tables.set-table-style( + table( + columns: (1.45fr, 1fr, 1fr, 1fr), + align: (left, right, right, right), + table.header([Arme], [5 dés], [8 dés], [14 dés]), + ..breakpoint-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.2pt, + ) +} diff --git a/setup/analysis/weapon_breakpoint_report.typ b/setup/analysis/weapon_breakpoint_report.typ new file mode 100644 index 0000000..0c98999 --- /dev/null +++ b/setup/analysis/weapon_breakpoint_report.typ @@ -0,0 +1,260 @@ +// Visual report for the weapon sensitivity cube and its computed breakpoints. +#import "@preview/primaviz:0.6.0": correlation-matrix, heatmap, multi-scatter-plot +#import "weapon_breakpoints.typ": * +#import "report_style.typ": chart-theme, rounded +#import "../theme/tables.typ" as tables +#import "../theme/themes.typ": make-theme + +#let report-theme = make-theme(theme-name: "steingrund") +#let sensitivity-palette = ( + report-theme.at("chart-4"), + report-theme.at("chart-3"), + report-theme.at("chart-2"), + report-theme.at("parchment-light"), +) +#let correlation-palette = ( + report-theme.at("chart-1"), + report-theme.at("parchment-light"), + report-theme.at("chart-2"), +) + +#let shape-short = ( + "Griffes": "Grif.", "Hast": "Hast", "Épée": "Épée", + "Marteau": "Mart.", "Hache": "Hache", "Arbalète": "Arba.", "Arc": "Arc", +) +#let nature-short = (Light: "L", Medium: "M", Heavy: "Ld", SuperHeavy: "SL") +#let weapon-row-labels = all-weapon-metrics.map(item => [ + #shape-short.at(item.shape) · #nature-short.at(item.nature-key) +]) +#let swing-columns = comparison-dice-pools.fold((), (labels, dice) => ( + labels + ([−1 · #dice d], [+1 · #dice d]) +)) + +#let sensitivity-heatmap(title, values) = block( + breakable: false, +)[ + #heading(level: 5)[#title] + #align(center, heatmap( + (rows: weapon-row-labels, cols: swing-columns, values: values), + cell-size: 20pt, + show-values: true, + show-legend: true, + palette: correlation-palette, + theme: chart-theme, + )) +] + +#let weapon-breakpoint-report() = { + pagebreak() + heading(level: 3)[Sensibilité, corrélations et points de rupture] + [Cette étude balaie automatiquement les #weapon-sensitivity-cube.len() combinaisons de + #analyzed-base-precisions.len() seuils de base, + #analyzed-dice-pools.len() tailles de pool et #all-weapon-metrics.len() armes. + Chaque observation conserve les modificateurs propres à l’arme, `R.Max` et le + meilleur partage possible sur 2A.] + + heading(level: 4)[Impact d’un point d’équilibrage] + [Ces cartes répondent directement à « que coûte ou rapporte un point ? ». Les + valeurs sont les variations relatives des dégâts attendus par rapport à + l’arme actuelle. Chaque variante recalcule aussi le meilleur partage du pool; + un saut peut donc révéler un changement de stratégie, pas seulement un effet + arithmétique local.] + + let sensitivity-rows = point-sensitivity-summary.map(row => ( + str(row.dice), + rounded(row.precision-loss, digits: 1) + [%], + rounded(row.precision-gain, digits: 1) + [%], + rounded(row.p-damage-loss, digits: 1) + [%], + rounded(row.p-damage-gain, digits: 1) + [%], + )) + tables.set-table-style( + table( + columns: (0.65fr,) + (1fr,) * 4, + align: (right,) * 5, + table.header( + [Pool], [Préc. −1], [Préc. +1], [Dég./réuss. −1], [Dég./réuss. +1], + ), + ..sensitivity-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) + + let paired-impact(row, loss-key, gain-key) = ( + (calc.abs(row.at(loss-key)) + calc.abs(row.at(gain-key))) / 2 + ) + let precision-impacts = point-sensitivity-summary.map(row => ( + paired-impact(row, "precision-loss", "precision-gain") + )) + let p-damage-impacts = point-sensitivity-summary.map(row => ( + paired-impact(row, "p-damage-loss", "p-damage-gain") + )) + let trend-word(values) = if values.last() < values.first() { + "diminue" + } else if values.last() > values.first() { + "augmente" + } else { + "reste stable" + } + let relative-evolution(values) = if values.first() == 0 { 0 } else { + (values.last() / values.first() - 1) * 100 + } + + [*Conclusion calculée.* L’impact moyen absolu d’un point de précision + #trend-word(precision-impacts), de + #rounded(precision-impacts.first(), digits: 1)% à + #point-sensitivity-summary.first().dice dés à + #rounded(precision-impacts.last(), digits: 1)% à + #point-sensitivity-summary.last().dice dés + (#rounded(relative-evolution(precision-impacts), digits: 1)%). Celui d’un point + de dégâts par réussite #trend-word(p-damage-impacts), de + #rounded(p-damage-impacts.first(), digits: 1)% à + #rounded(p-damage-impacts.last(), digits: 1)% + (#rounded(relative-evolution(p-damage-impacts), digits: 1)%). Cette phrase, + ses valeurs et ses verbes sont reconstruits à chaque compilation.] + + sensitivity-heatmap( + [Précision ±1 — variation des dégâts (%)], + precision-swing-grid, + ) + sensitivity-heatmap( + [Dégâts par réussite ±1 — variation des dégâts (%)], + p-damage-swing-grid, + ) + + pagebreak() + heading(level: 4)[Seuil × arme à engagement fixe] + [Ces cartes conservent chaque arme individuellement et font varier le seuil de + base. Elles permettent de voir si une arme reste stable entre les régimes de + faible engagement, d’engagement médian et de saturation.] + for dice in comparison-dice-pools { + block(breakable: false)[ + #heading(level: 5)[Espérance à #dice dés] + #align(center, heatmap( + ( + rows: weapon-row-labels, + cols: analyzed-base-precisions.map(value => [Seuil #value]), + values: weapon-threshold-grid(dice), + ), + cell-size: 17pt, + show-values: true, + palette: sensitivity-palette, + theme: chart-theme, + )) + ] + } + + heading(level: 4)[Surface de dégâts attendus] + [Les cellules agrègent la moyenne de toutes les armes. Le seuil indiqué est + la valeur naturelle avant application du modificateur de précision de l’arme.] + heatmap( + ( + rows: analyzed-base-precisions.map(value => [Seuil #value]), + cols: analyzed-dice-pools.map(value => [#value dés]), + values: average-damage-grid, + ), + cell-size: 32pt, + show-values: true, + palette: sensitivity-palette, + theme: chart-theme, + ) + + heading(level: 4)[Rendement marginal d’un dé supplémentaire] + [Chaque cellule mesure `E[dégâts à n dés] − E[dégâts à n−1 dés]`. Les zones + sombres signalent les pools où `R.Max` et la précision ont déjà absorbé + l’essentiel du rendement marginal.] + heatmap( + ( + rows: analyzed-base-precisions.map(value => [Seuil #value]), + cols: marginal-dice-pools.map(value => [→ #value dés]), + values: average-marginal-grid, + ), + cell-size: 32pt, + show-values: true, + palette: sensitivity-palette, + theme: chart-theme, + ) + [Le gain moyen maximal calculé est de + #rounded(strongest-marginal.gain, digits: 2) dégâts en passant à + #strongest-marginal.dice dés au seuil #strongest-marginal.base-precision. + À l’autre extrême, il tombe à #rounded(weakest-marginal.gain, digits: 2) en + passant à #weakest-marginal.dice dés au seuil #weakest-marginal.base-precision.] + + heading(level: 4)[Trajectoires dés × précision] + multi-scatter-plot( + ( + series: (2, 4, 6, 8).map(precision => ( + name: "Seuil " + str(precision), + points: analyzed-dice-pools.map(dice => ( + dice, average-swept-damage(precision, dice), + )), + )), + ), + width: 100%, + height: 225pt, + point-size: 5pt, + x-label: [Dés engagés], + y-label: [Dégâts moyens attendus], + theme: chart-theme, + ) + + heading(level: 4)[Corrélations globales] + [La matrice mesure les corrélations de Pearson sur le cube complet. Elle décrit + des associations, pas une causalité; les effets non linéaires de `R.Max` sont + détaillés par les cartes et les ruptures.] + correlation-matrix( + ( + labels: correlation-fields.map(field => field.label), + values: weapon-correlation-values, + ), + cell-size: 36pt, + show-values: true, + palette: correlation-palette, + theme: chart-theme, + ) + + let correlation-rows = damage-correlations.map(result => ( + result.label, + rounded(result.value, digits: 3), + if result.value >= 0 { [Positive] } else { [Négative] }, + )) + tables.set-table-style( + table( + columns: (1.4fr, 0.8fr, 0.9fr), + align: (left, right, left), + table.header([Variable], [Corr. avec E[dég.]], [Sens]), + ..correlation-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) + let strongest = damage-correlations.first() + [La relation linéaire la plus forte avec les dégâts attendus est calculée pour + *#strongest.label* ($r = #rounded(strongest.value, digits: 3)$). Le classement + ci-dessus est entièrement recalculé avec le cube.] + + heading(level: 4)[Rupture de rendement] + [Le point de rupture est détecté sans seuil arbitraire: pour chaque courbe, il + s’agit du point de plus forte courbure normalisée entre + #analyzed-dice-pools.first() et #analyzed-dice-pools.last() dés.] + let knee-rows = knee-summary.map(row => ( + str(row.precision), + rounded(row.median-dice, digits: 1), + rounded(row.average-damage, digits: 2), + rounded(row.average-end-damage, digits: 2), + rounded(row.retained * 100, digits: 1) + [%], + )) + tables.set-table-style( + table( + columns: (0.8fr, 1fr, 1.15fr, 1.15fr, 1fr), + align: (right,) * 5, + table.header( + [Seuil], [Rupture médiane], [Dég. à rupture], [Dég. à 14 dés], + [Part atteinte], + ), + ..knee-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) +} diff --git a/setup/analysis/weapon_breakpoints.typ b/setup/analysis/weapon_breakpoints.typ new file mode 100644 index 0000000..a3d156d --- /dev/null +++ b/setup/analysis/weapon_breakpoints.typ @@ -0,0 +1,214 @@ +// Sensitivity cube and breakpoint statistics for generated weapons. +// Every value is derived from the exact binomial model in weapon_metrics.typ. +#import "weapon_metrics.typ": * +#import "report_config.typ": inclusive-range, sensitivity-settings + +#let analyzed-base-precisions = inclusive-range(sensitivity-settings.base_precision) +#let analyzed-dice-pools = inclusive-range(sensitivity-settings.dice) +#let comparison-dice-pools = sensitivity-settings.comparison_dice + +#let mean(values) = values.sum() / values.len() + +#let numeric-median(values) = { + let ordered = values.sorted() + let middle = calc.floor(ordered.len() / 2) + if calc.rem(ordered.len(), 2) == 0 { + (ordered.at(middle - 1) + ordered.at(middle)) / 2 + } else { + ordered.at(middle) + } +} + +#let analyzed-probability(base-precision, weapon-precision) = ( + calc.max(0, calc.min(10, base-precision + weapon-precision)) / 10 +) + +#let swept-damage(item, base-precision, dice) = commitment-analysis( + item.base-damage, + item.p-damage, + item.rmax, + item.actions, + dice, + analyzed-probability(base-precision, item.precision), +).best + +#let perturbed-damage( + item, + dice, + precision-delta: 0, + p-damage-delta: 0, + base-precision: natural-precision, +) = commitment-analysis( + item.base-damage, + item.p-damage + p-damage-delta, + item.rmax, + item.actions, + dice, + analyzed-probability(base-precision, item.precision + precision-delta), +).best + +#let relative-change(item, dice, precision-delta: 0, p-damage-delta: 0) = { + let baseline = perturbed-damage(item, dice) + let changed = perturbed-damage( + item, + dice, + precision-delta: precision-delta, + p-damage-delta: p-damage-delta, + ) + if baseline == 0 { 0 } else { (changed / baseline - 1) * 100 } +} + +#let weapon-threshold-grid(dice) = all-weapon-metrics.map(item => ( + analyzed-base-precisions.map(precision => swept-damage(item, precision, dice)) +)) + +#let weapon-sensitivity-grid(precision-delta: 0, p-damage-delta: 0) = ( + all-weapon-metrics.map(item => comparison-dice-pools.map(dice => relative-change( + item, + dice, + precision-delta: precision-delta, + p-damage-delta: p-damage-delta, + ))) +) + +#let precision-loss-grid = weapon-sensitivity-grid(precision-delta: -1) +#let precision-gain-grid = weapon-sensitivity-grid(precision-delta: 1) +#let p-damage-loss-grid = weapon-sensitivity-grid(p-damage-delta: -1) +#let p-damage-gain-grid = weapon-sensitivity-grid(p-damage-delta: 1) +#let precision-swing-grid = precision-loss-grid.zip(precision-gain-grid).map(pair => ( + range(0, comparison-dice-pools.len()).fold((), (values, index) => ( + values + (pair.at(0).at(index), pair.at(1).at(index)) + )) +)) +#let p-damage-swing-grid = p-damage-loss-grid.zip(p-damage-gain-grid).map(pair => ( + range(0, comparison-dice-pools.len()).fold((), (values, index) => ( + values + (pair.at(0).at(index), pair.at(1).at(index)) + )) +)) +#let point-sensitivity-summary = comparison-dice-pools.enumerate().map(pair => { + let index = pair.at(0) + let dice = pair.at(1) + ( + dice: dice, + precision-loss: mean(precision-loss-grid.map(row => row.at(index))), + precision-gain: mean(precision-gain-grid.map(row => row.at(index))), + p-damage-loss: mean(p-damage-loss-grid.map(row => row.at(index))), + p-damage-gain: mean(p-damage-gain-grid.map(row => row.at(index))), + ) +}) + +#let weapon-sensitivity-cube = analyzed-base-precisions.fold((), (rows, precision) => ( + rows + analyzed-dice-pools.fold((), (pool-rows, dice) => ( + pool-rows + all-weapon-metrics.map(item => ( + weapon: item.name, + shape: item.shape, + nature: item.nature, + base-precision: precision, + effective-precision: calc.max(0, calc.min(10, precision + item.precision)), + dice: dice, + base-damage: item.base-damage, + p-damage: item.p-damage, + rmax: item.rmax, + actions: item.actions, + armor-break: item.armor-break, + expected-damage: swept-damage(item, precision, dice), + )) + )) +)) + +#let average-swept-damage(base-precision, dice) = mean( + all-weapon-metrics.map(item => swept-damage(item, base-precision, dice)), +) + +#let average-damage-grid = analyzed-base-precisions.map(precision => ( + analyzed-dice-pools.map(dice => average-swept-damage(precision, dice)) +)) + +#let marginal-dice-pools = analyzed-dice-pools.slice(1) +#let average-marginal-grid = analyzed-base-precisions.map(precision => ( + marginal-dice-pools.map(dice => ( + average-swept-damage(precision, dice) + - average-swept-damage(precision, dice - 1) + )) +)) + +#let marginal-observations = analyzed-base-precisions.fold((), (rows, precision) => ( + rows + marginal-dice-pools.map(dice => ( + base-precision: precision, + dice: dice, + gain: average-swept-damage(precision, dice) + - average-swept-damage(precision, dice - 1), + )) +)) +#let strongest-marginal = marginal-observations.sorted(key: point => -point.gain).first() +#let weakest-marginal = marginal-observations.sorted(key: point => point.gain).first() + +#let pearson(records, x-key, y-key) = { + let xs = records.map(row => row.at(x-key)) + let ys = records.map(row => row.at(y-key)) + let x-mean = mean(xs) + let y-mean = mean(ys) + let numerator = xs.zip(ys).map(pair => ( + (pair.at(0) - x-mean) * (pair.at(1) - y-mean) + )).sum() + let x-square = xs.map(value => calc.pow(value - x-mean, 2)).sum() + let y-square = ys.map(value => calc.pow(value - y-mean, 2)).sum() + if x-square == 0 or y-square == 0 { 0 } else { + numerator / calc.sqrt(x-square * y-square) + } +} + +#let correlation-fields = ( + (key: "base-precision", label: "Seuil"), + (key: "dice", label: "Dés"), + (key: "base-damage", label: "Dég."), + (key: "p-damage", label: "+/réuss."), + (key: "rmax", label: "R.Max"), + (key: "actions", label: "Actions"), + (key: "armor-break", label: "Brise"), + (key: "expected-damage", label: "E[dég.]"), +) + +#let weapon-correlation-values = correlation-fields.map(left => ( + correlation-fields.map(right => pearson( + weapon-sensitivity-cube, left.key, right.key, + )) +)) + +#let damage-correlations = correlation-fields.filter(field => ( + field.key != "expected-damage" +)).map(field => ( + label: field.label, + value: pearson(weapon-sensitivity-cube, field.key, "expected-damage"), +)).sorted(key: result => -calc.abs(result.value)) + +// Discrete knee: greatest normalized height above the line joining the first +// and last points. This detects where a concave damage curve bends most. +#let weapon-knee(item, base-precision) = { + let damages = analyzed-dice-pools.map(dice => swept-damage(item, base-precision, dice)) + let first-damage = damages.first() + let damage-span = damages.last() - first-damage + let dice-span = analyzed-dice-pools.last() - analyzed-dice-pools.first() + let candidates = analyzed-dice-pools.enumerate().map(pair => { + let index = pair.at(0) + let dice = pair.at(1) + let x = (dice - analyzed-dice-pools.first()) / dice-span + let y = if damage-span == 0 { 0 } else { + (damages.at(index) - first-damage) / damage-span + } + (dice: dice, damage: damages.at(index), curvature: y - x) + }) + candidates.sorted(key: point => -point.curvature).first() +} + +#let knee-summary = analyzed-base-precisions.map(precision => { + let knees = all-weapon-metrics.map(item => weapon-knee(item, precision)) + let end-damages = all-weapon-metrics.map(item => swept-damage(item, precision, 14)) + ( + precision: precision, + median-dice: numeric-median(knees.map(knee => knee.dice)), + average-damage: mean(knees.map(knee => knee.damage)), + average-end-damage: mean(end-damages), + retained: mean(knees.map(knee => knee.damage)) / mean(end-damages), + ) +}) diff --git a/setup/analysis/weapon_metrics.typ b/setup/analysis/weapon_metrics.typ new file mode 100644 index 0000000..6273ede --- /dev/null +++ b/setup/analysis/weapon_metrics.typ @@ -0,0 +1,147 @@ +// Offensive metrics derived from the same composed equipment records used by +// the forge table. Keep formulas here so future metrics share one data model. +#import "../../chapters/craft/forge-data.typ": equipments +#import "report_config.typ": weapon-settings + +#let weapon-nature-labels = ( + Light: "Léger", + Medium: "Moyen", + Heavy: "Lourd", + SuperHeavy: "Super-lourd", +) + +// The first success deals base damage. Each later success adds `p-damage`. +#let damage-at-successes(base-damage, p-damage, successes) = if successes <= 0 { + 0 +} else { + base-damage + (successes - 1) * p-damage +} + +// Guard the core rule against regressions as the metric model grows. +#assert.eq(damage-at-successes(8, 2, 5), 16) + +// A precision modifier is applied to the natural precision of 7. Each point +// changes the success probability of one die by 10 percentage points. +#let natural-precision = weapon-settings.natural_precision +#let precision-die-sides = weapon-settings.die_sides +#let success-probability(precision) = ( + calc.max(0, calc.min(precision-die-sides, natural-precision + precision)) + / precision-die-sides +) + +#let binomial-probability(dice, successes, probability) = ( + calc.binom(dice, successes) + * (if successes == 0 { 1 } else { calc.pow(probability, successes) }) + * (if dice == successes { 1 } else { + calc.pow(1 - probability, dice - successes) + }) +) + +// Expected damage of one attack. Successes beyond R.Max still occur, but do +// not increase damage and are therefore folded into the capped damage value. +#let expected-attack-damage(base-damage, p-damage, rmax, dice, probability) = { + range(0, dice + 1).map(successes => ( + binomial-probability(dice, successes, probability) + * damage-at-successes(base-damage, p-damage, calc.min(successes, rmax)) + )).sum() +} + +#assert.eq(expected-attack-damage(8, 2, 5, 1, 1), 8) +#assert.eq(expected-attack-damage(8, 2, 5, 5, 1), 16) + +#let commitment-pools = weapon-settings.damage_scenarios.map(item => ( + key: item.key, + label: item.label, + dice: item.dice, +)) + +#let commitment-analysis(base-damage, p-damage, rmax, actions, dice, probability) = { + let single = expected-attack-damage( + base-damage, p-damage, rmax, dice, probability, + ) + let candidates = if actions == 1 and dice >= 2 { + range(1, calc.floor(dice / 2) + 1).map(first => ( + first: first, + second: dice - first, + damage: expected-attack-damage( + base-damage, p-damage, rmax, first, probability, + ) + expected-attack-damage( + base-damage, p-damage, rmax, dice - first, probability, + ), + )) + } else { + () + } + let best-split = if candidates.len() == 0 { none } else { + candidates.sorted(key: candidate => -candidate.damage).first() + } + let use-split = best-split != none and best-split.damage > single + ( + dice: dice, + single: single, + split: best-split, + best: if use-split { best-split.damage } else { single }, + strategy: if use-split { + str(best-split.first) + "+" + str(best-split.second) + } else { + str(dice) + }, + attacks: if use-split { 2 } else { 1 }, + ) +} + +#let analyze-weapon(item) = { + let actions = calc.max(1, item.action_cost) + let capped-damage = damage-at-successes(item.damage, item.p_damage, item.rmax) + let probability = success-probability(item.precision) + let commitments = (:) + for commitment in commitment-pools { + commitments.insert(commitment.key, commitment-analysis( + item.damage, + item.p_damage, + item.rmax, + actions, + commitment.dice, + probability, + )) + } + ( + name: item.shape_name + " · " + weapon-nature-labels.at(item.nature_category), + shape: item.shape_name, + nature: weapon-nature-labels.at(item.nature_category), + nature-key: item.nature_category, + base-damage: item.damage, + p-damage: item.p_damage, + precision: item.precision, + effective-precision: natural-precision + item.precision, + success-probability: probability, + rmax: item.rmax, + armor-break: item.armor_break, + actions: actions, + max-damage: capped-damage, + damage-per-action: capped-damage / actions, + commitments: commitments, + damage-curve: range(1, item.rmax + 1).map(successes => ( + successes: successes, + damage: damage-at-successes(item.damage, item.p_damage, successes), + )), + source: item, + ) +} + +#let all-weapon-metrics = equipments.filter(item => ( + item.apply_category == "Weapons" +)).map(analyze-weapon) + +#let weapon-shapes = all-weapon-metrics.map(item => item.shape).dedup() +#let weapon-natures = ("Light", "Medium", "Heavy", "SuperHeavy") + +#let weapon-average(key, weapons: all-weapon-metrics) = { + if weapons.len() == 0 { none } else { + weapons.map(item => item.at(key)).sum() / weapons.len() + } +} + +#let ranked-weapons(key, weapons: all-weapon-metrics) = weapons.sorted( + key: item => -item.at(key), +) diff --git a/setup/analysis/weapon_report.typ b/setup/analysis/weapon_report.typ new file mode 100644 index 0000000..60a430f --- /dev/null +++ b/setup/analysis/weapon_report.typ @@ -0,0 +1,260 @@ +// Presentation layer for generated weapon balancing metrics. +#import "@preview/primaviz:0.6.0": grouped-bar-chart, grouped-stacked-bar-chart, horizontal-bar-chart +#import "weapon_metrics.typ": * +#import "report_style.typ": chart-theme, metric-card, rounded +#import "../theme/tables.typ" as tables +#import "weapon_armor_breakpoints.typ": armor-commitment-analysis +#import "report_config.typ": armor-settings + +#let low-scenario = commitment-pools.find(item => item.key == "low") +#let mid-scenario = commitment-pools.find(item => item.key == "mid") +#let full-scenario = commitment-pools.find(item => item.key == "full") + +#let weapon-series(key) = weapon-natures.map(nature => ( + name: weapon-nature-labels.at(nature), + values: weapon-shapes.map(shape => all-weapon-metrics.find(item => ( + item.shape == shape and item.nature-key == nature + )).at(key)), +)) + +#let weapon-value-matrix(key, digits: 1) = { + let rows = () + for shape in weapon-shapes { + rows.push(shape) + for nature in weapon-natures { + rows.push(rounded(all-weapon-metrics.find(item => ( + item.shape == shape and item.nature-key == nature + )).at(key), digits: digits)) + } + } + tables.set-table-style( + table( + columns: (1.3fr,) + (0.8fr,) * weapon-natures.len(), + align: (left,) + (right,) * weapon-natures.len(), + table.header([Forme], ..weapon-natures.map(nature => [#weapon-nature-labels.at(nature)])), + ..rows, + ), + table-theme: "steingrund", + text-size: 7.5pt, + ) +} + +#let expected-damage-cell(item, commitment-key) = { + let result = item.commitments.at(commitment-key) + [#rounded(result.best, digits: 2) #text(size: 6pt, fill: luma(90))[#result.strategy dés]] +} + +#let commitment-stacked-groups = weapon-natures.map(nature => { + let values = weapon-shapes.map(shape => all-weapon-metrics.find(item => ( + item.shape == shape and item.nature-key == nature + ))) + ( + name: weapon-nature-labels.at(nature), + segments: ( + (name: str(low-scenario.dice) + " dés", values: values.map(item => item.commitments.low.best)), + (name: "Gain " + str(low-scenario.dice) + "→" + str(mid-scenario.dice), values: values.map(item => ( + item.commitments.mid.best - item.commitments.low.best + ))), + (name: "Gain " + str(mid-scenario.dice) + "→" + str(full-scenario.dice), values: values.map(item => ( + item.commitments.full.best - item.commitments.mid.best + ))), + ), + ) +}) + +#let weapon-analysis-report() = { + pagebreak() + heading(level: 2)[Artisanat — Équilibre des armes] + + let max-ranked = ranked-weapons("max-damage") + let action-ranked = ranked-weapons("damage-per-action") + let break-ranked = ranked-weapons("armor-break") + + grid( + columns: (1fr,) * 4, + column-gutter: 8pt, + metric-card("Armes générées", all-weapon-metrics.len()), + metric-card("Dégâts max. moyens", rounded(weapon-average("max-damage"), digits: 1)), + metric-card("Dégâts/action moyens", rounded(weapon-average("damage-per-action"), digits: 1)), + metric-card("Brise-armure moyen", rounded(weapon-average("armor-break"), digits: 1)), + ) + + [Les dégâts à $n$ réussites valent `Dégâts + (n − 1) × Dégâts/réussite`. + Les dégâts maximaux utilisent `R.Max`; les dégâts par action divisent ce + résultat par le coût d’action généré de l’arme.] + + heading(level: 3)[Dégâts probabilistes sur 2 actions] + [Chaque dé réussit avec une probabilité de + `(Précision naturelle + modificateur) / faces`, soit + `(#natural-precision + Précision) / #precision-die-sides`. Les + espérances ci-dessous utilisent la distribution binomiale exacte et plafonnent + les dégâts à `R.Max`. Pour une arme à 1A, toutes les répartitions possibles du + pool entre deux attaques sont comparées à une attaque unique; la meilleure + option est affichée. Une arme à 2A conserve nécessairement le pool entier.] + + let expectation-rows = all-weapon-metrics.map(item => ( + item.name, + str(item.effective-precision), + str(calc.round(item.success-probability * 100)) + "%", + expected-damage-cell(item, "low"), + expected-damage-cell(item, "mid"), + expected-damage-cell(item, "full"), + )) + tables.set-table-style( + table( + columns: (1.5fr, 0.52fr, 0.62fr, 0.85fr, 0.85fr, 0.85fr), + align: (left,) + (right,) * 5, + table.header( + [Arme], [Préc.], [Chance/dé], + [#low-scenario.label · #low-scenario.dice dés], + [#mid-scenario.label · #mid-scenario.dice dés], + [#full-scenario.label · #full-scenario.dice dés], + ), + ..expectation-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 7.2pt, + ) + + heading(level: 3)[Dégâts maximaux par forme et poids] + grouped-bar-chart( + (labels: weapon-shapes, series: weapon-series("max-damage")), + width: 100%, height: 205pt, y-label: [Dégâts à R.Max], theme: chart-theme, + ) + weapon-value-matrix("max-damage", digits: 0) + + heading(level: 3)[Dégâts maximaux par action] + grouped-bar-chart( + (labels: weapon-shapes, series: weapon-series("damage-per-action")), + width: 100%, height: 205pt, y-label: [Dégâts / action], theme: chart-theme, + ) + weapon-value-matrix("damage-per-action", digits: 1) + + heading(level: 3)[Dégâts attendus à #low-scenario.dice, #mid-scenario.dice et #full-scenario.dice dés] + [Pour chaque forme, les quatre barres suivent l’ordre léger, moyen, lourd, + super-lourd. L’empilement est cumulatif: le premier segment donne les dégâts + à #low-scenario.dice dés, puis les gains supplémentaires jusqu’à + #mid-scenario.dice et #full-scenario.dice dés. Le sommet est donc l’espérance + réelle à #full-scenario.dice dés.] + grouped-stacked-bar-chart( + (labels: weapon-shapes, groups: commitment-stacked-groups), + width: 100%, + height: 230pt, + y-label: [Dégâts attendus sur 2A], + theme: chart-theme, + ) + + heading(level: 3)[Plan de bataille — Sélection des armes] + let low-leader = all-weapon-metrics.sorted( + key: item => -item.commitments.low.best, + ).first() + let full-leader = all-weapon-metrics.sorted( + key: item => -item.commitments.full.best, + ).first() + let armor-protection = armor-settings.utilization_protection + let armor-dice = armor-settings.utilization_dice + let armor-leader = all-weapon-metrics.map(item => ( + item: item, + value: armor-commitment-analysis(item, armor-dice, armor-protection).destruction, + )).sorted(key: result => -result.value).first() + let scaling-leader = all-weapon-metrics.map(item => ( + item: item, + gain: item.commitments.full.best - item.commitments.low.best, + )).sorted(key: result => -result.gain).first() + grid( + columns: (1fr, 1fr), + column-gutter: 12pt, + row-gutter: 12pt, + metric-card( + "Faible engagement", low-leader.name, + note: [#rounded(low-leader.commitments.low.best, digits: 2) dégâts à #low-scenario.dice dés], + ), + metric-card( + "Engagement total", full-leader.name, + note: [#rounded(full-leader.commitments.full.best, digits: 2) dégâts à #full-scenario.dice dés], + ), + metric-card( + "Destruction d’armure", armor-leader.item.name, + note: [#rounded(armor-leader.value, digits: 2) armure contre P#armor-protection à #armor-dice dés], + ), + metric-card( + "Meilleure montée en puissance", scaling-leader.item.name, + note: [+#rounded(scaling-leader.gain, digits: 2) dégâts entre #low-scenario.dice et #full-scenario.dice dés], + ), + ) + + heading(level: 3)[Classements offensifs] + grid( + columns: (1fr, 1fr, 1fr), + column-gutter: 10pt, + horizontal-bar-chart( + (labels: max-ranked.slice(0, 8).map(item => item.name), values: max-ranked.slice(0, 8).map(item => item.max-damage)), + width: 100%, height: 210pt, title: [Dégâts maximaux], show-values: true, theme: chart-theme, + ), + horizontal-bar-chart( + (labels: action-ranked.slice(0, 8).map(item => item.name), values: action-ranked.slice(0, 8).map(item => item.damage-per-action)), + width: 100%, height: 210pt, title: [Dégâts par action], show-values: true, theme: chart-theme, + ), + horizontal-bar-chart( + (labels: break-ranked.slice(0, 8).map(item => item.name), values: break-ranked.slice(0, 8).map(item => item.armor-break)), + width: 100%, height: 210pt, title: [Brise-armure], show-values: true, theme: chart-theme, + ), + ) + + heading(level: 3)[Tableau d’équilibrage] + let rows = all-weapon-metrics.map(item => ( + item.name, + str(item.base-damage), + if item.p-damage >= 0 { "+" + str(item.p-damage) } else { str(item.p-damage) }, + str(item.rmax), + str(item.max-damage), + str(item.armor-break), + str(item.actions) + "A", + rounded(item.damage-per-action, digits: 1), + rounded(item.commitments.low.best, digits: 2), + rounded(item.commitments.mid.best, digits: 2), + rounded(item.commitments.full.best, digits: 2), + )) + tables.set-table-style( + table( + columns: ( + 1.55fr, 0.46fr, 0.42fr, 0.48fr, 0.62fr, 0.52fr, + 0.48fr, 0.62fr, 0.62fr, 0.62fr, 0.62fr, + ), + align: (left,) + (right,) * 10, + table.header( + [Arme], [Dég.], [+], [R.Max], [Dég. max], [Brise], [Actions], + [Dég./A], [E·#low-scenario.dice d], [E·#mid-scenario.dice d], + [E·#full-scenario.dice d], + ), + ..rows.flatten(), + ), + table-theme: "steingrund", + text-size: 6.5pt, + ) + + heading(level: 3)[Courbes de dégâts par réussite] + let curve-rows = () + let max-successes = all-weapon-metrics.map(item => item.rmax).sorted().last() + for item in all-weapon-metrics { + curve-rows.push(item.name) + for successes in range(1, max-successes + 1) { + if successes <= item.rmax { + curve-rows.push(str(damage-at-successes(item.base-damage, item.p-damage, successes))) + } else { + curve-rows.push(text(size: 6pt, smallcaps[(capped)])) + } + } + } + tables.set-table-style( + table( + columns: (1.65fr,) + (0.65fr,) * max-successes, + align: (left,) + (right,) * max-successes, + table.header([Arme], ..range(1, max-successes + 1).map(successes => [#successes réuss.])), + ..curve-rows, + ), + table-theme: "steingrund", + text-size: 7pt, + ) + +} diff --git a/setup/build_config.typ b/setup/build_config.typ index 4a3968e..f4cd547 100644 --- a/setup/build_config.typ +++ b/setup/build_config.typ @@ -1,7 +1,9 @@ -// Shared build-time data limits. +// Shared build-time data limits, sourced from the report configuration. // Tiers are included when `tier < max-tier-exclusive`. +#import "analysis/report_config.typ": build-settings + #let build-config = ( - max-tier-exclusive: 5, + max-tier-exclusive: build-settings.max_tier_exclusive, ) #let max-tier-exclusive = build-config.max-tier-exclusive diff --git a/setup/theme/symbols.typ b/setup/theme/symbols.typ index 698357c..5aa5f0e 100644 --- a/setup/theme/symbols.typ +++ b/setup/theme/symbols.typ @@ -20,7 +20,7 @@ height: 0.65em, baseline: 0.5pt, inset: 0pt, - image("/images/icons/blood.png"), + image("/images/icons/blood.svg"), ) #let jauge-box = box( height: 0.65em, @@ -80,13 +80,13 @@ height: 0.65em, baseline: 0.5pt, inset: 0pt, - image("/images/icons/protection.png"), + image("/images/icons/protection.svg"), ) #let integrity-box = box( height: 0.65em, baseline: 0.5pt, inset: 0pt, - image("/images/icons/integrity.png"), + image("/images/icons/integrity.svg"), ) #let cost-box = box( height: 0.65em,