diff --git a/setup/analysis/class_weapon_metrics.typ b/setup/analysis/class_weapon_metrics.typ index 0ea903d..13a59a6 100644 --- a/setup/analysis/class_weapon_metrics.typ +++ b/setup/analysis/class_weapon_metrics.typ @@ -95,8 +95,12 @@ precision: if found.captures.at(5).contains("Précision +1") { 1 } else { 0 }, )) let loaders = source.matches(regex("\\[Chargeur (Rotatif|Long|Unique)\\]")).map(found => found.captures.at(0)) + let unique-damage = source.match(regex("(?s)\\[Chargeur Unique\\],\\s*\\n\\s*\\[[^]]+\\],\\s*\\n\\s*\\[\\+([0-9]+)/\\+([0-9]+)\\]")) + let unique-base-bonus = if unique-damage == none { 0 } else { int(unique-damage.captures.at(0)) } + let unique-p-bonus = if unique-damage == none { 0 } else { int(unique-damage.captures.at(1)) } let cannons = ("Simple", "Double") let profiles = () + let issues = () for base in bases { for cannon in cannons { for loader in loaders { @@ -104,22 +108,25 @@ let unique = loader == "Unique" let metric = analyze-weapon-profile( base.name + " · Canon " + cannon + " · " + loader, - base.damage + (if unique { 1 } else { 0 }), - base.p-damage + (if simple { 1 } else { 0 }), + base.damage + (if unique { unique-base-bonus } else { 0 }), + base.p-damage + (if simple { 1 } else { 0 }) + (if unique { unique-p-bonus } else { 0 }), base.rmax + (if simple { 1 } else { 0 }), precision: base.precision + (if cannon == "Double" { 4 } else { 0 }), actions: 1, - damage-multiplier: if cannon == "Double" { 2 } else { 1 }, source: source, ) - profiles.push((school: "Artilleur", tier: none, technique: metric.name, - base-token: str(base.damage), channelled: false, metric: metric)) + profiles.push(( + school: "Artilleur", tier: none, technique: metric.name, + base-token: str(base.damage), channelled: false, metric: metric, + artillery-base: base.name, artillery-cannon: cannon, + artillery-loader: loader, + )) } } } - let issues = () if bases.len() == 0 { issues.push((school: "Artilleur", technique: "Bases", tier: none, reason: "Aucune base de canon reconnue")) } if loaders.len() == 0 { issues.push((school: "Artilleur", technique: "Chargeurs", tier: none, reason: "Aucun chargeur reconnu")) } + if unique-damage == none { issues.push((school: "Artilleur", technique: "Chargeur Unique", tier: none, reason: "Modificateur +X/+Y illisible")) } (profiles: profiles, issues: issues) } diff --git a/setup/analysis/class_weapon_report.typ b/setup/analysis/class_weapon_report.typ index 2692fc4..1f135c7 100644 --- a/setup/analysis/class_weapon_report.typ +++ b/setup/analysis/class_weapon_report.typ @@ -32,8 +32,28 @@ short } #let chart-profile-label(profile) = compact-profile-name(profile.metric.name) + " · " + compact-action-label(profile) +#let offensive-signature(profile) = { + let item = profile.metric + ( + item.base-damage, item.p-damage, item.rmax, item.precision, + item.damage-multiplier, item.actions, profile.channelled, + ) +} +#let distinct-offensive-profiles(profiles) = { + let seen = () + let distinct = () + for profile in profiles { + let signature = offensive-signature(profile) + if signature not in seen { + seen.push(signature) + distinct.push(profile) + } + } + distinct +} #let school-chart(title, profiles) = { + let profiles = distinct-offensive-profiles(profiles) let metrics = profiles.map(profile => profile.metric) let benchmark-labels = ( "Moy. catalogue · fenêtre " + str(weapon-settings.action_budget) + "A", @@ -62,8 +82,9 @@ symboliques utilisent les valeurs de configuration. Une canalisation compte toutes ses actions et produit une seule attaque: elle ne peut jamais être chaînée dans la fenêtre comparative de deux actions. L’Alchimie de l’Artilleur - est volontairement exclue. Le Canon Double applique ses deux tirs simultanés - au même profil et le bonus de précision décrit par l’arbre; les chargeurs + est volontairement exclue. Les deux tirs du Canon Double ne multiplient pas + les dégâts: son emploi simultané applique uniquement le bonus de précision + décrit par l’arbre. Les chargeurs Rotatif et Long modifient l’autonomie, pas les dégâts immédiats.] grid(columns: (1fr, 1fr, 1fr), column-gutter: 9pt, @@ -72,6 +93,77 @@ metric-card("Référence haute", catalog-best.name), ) + heading(level: 3)[Paramètres calculés de l’Artilleur — 1 action] + [Ce tableau expose les valeurs réellement envoyées au moteur binomial. + `Impacts` indique le nombre d’instances de dégâts: il reste à `1`, y compris + pour le Canon Double, qui reçoit uniquement son bonus de précision de `+4`. + Les chargeurs sont conservés côte à côte pour vérifier + qu’ils ne modifient ni `R.Max`, ni les actions.] + let artillery-profiles = class-weapon-profiles.filter(profile => profile.school == "Artilleur") + let artillery-stat-rows = artillery-profiles.map(profile => { + let item = profile.metric + ( + profile.artillery-base, + profile.artillery-cannon, + profile.artillery-loader, + str(item.base-damage), + "+" + str(item.p-damage), + str(item.rmax), + if item.precision >= 0 { "+" + str(item.precision) } else { str(item.precision) }, + str(item.effective-precision), + str(item.damage-multiplier), + action-count-label(item.actions), + str(item.max-damage), + rounded(item.commitments.full.best, digits: 2), + ) + }) + tables.set-table-style( + table( + columns: (0.72fr, 0.62fr, 0.7fr, 0.42fr, 0.38fr, 0.42fr, 0.48fr, 0.48fr, 0.42fr, 0.65fr, 0.5fr, 0.62fr), + align: (left, left, left) + (right,) * 9, + table.header( + [Base], [Canon], [Chargeur], [Dég.], [+], [R.Max], [Préc. +], + [Préc.], [Impacts], [Actions], [Plafond], [E·#commitment-pools.last().dice d], + ), + ..artillery-stat-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 6.1pt, + ) + + [*Décomposition de l’espérance à #commitment-pools.last().dice dés sur + #weapon-settings.action_budget actions.* La colonne `E·1 attaque` conserve le + pool entier sur un seul jet. `E retenue` applique ensuite le meilleur partage + autorisé dans la fenêtre d’actions.] + let artillery-execution-rows = artillery-profiles.map(profile => { + let item = profile.metric + let result = item.commitments.full + ( + profile.artillery-base, + profile.artillery-cannon, + profile.artillery-loader, + result.strategy, + str(result.attacks), + str(item.damage-multiplier), + str(result.attacks * item.damage-multiplier), + rounded(result.single, digits: 2), + rounded(result.best, digits: 2), + ) + }) + tables.set-table-style( + table( + columns: (0.85fr, 0.75fr, 0.82fr, 0.65fr, 0.55fr, 0.72fr, 0.72fr, 0.78fr, 0.78fr), + align: (left, left, left) + (right,) * 6, + table.header( + [Base], [Canon], [Chargeur], [Dés], [Attaques], + [Imp./att.], [Imp. totaux], [E·1 attaque], [E retenue], + ), + ..artillery-execution-rows.flatten(), + ), + table-theme: "steingrund", + text-size: 6.3pt, + ) + heading(level: 3)[Dégâts maximaux par classe] [Le maximum applique la formule `base + (R.Max − 1) × dégâts/réussite`. Il représente le plafond brut d’un profil ayant atteint son nombre maximal @@ -130,6 +222,9 @@ ), table-theme: "steingrund", text-size: 6.7pt) heading(level: 3)[Dégâts attendus à #commitment-pools.map(item => str(item.dice)).join(", ") dés — #weapon-settings.action_budget actions ou canalisation complète] + [Les graphiques fusionnent automatiquement les variantes dont les paramètres + offensifs sont identiques. Les profils complets restent disponibles dans les + tableaux ci-dessus.] for school in ("Sangremage", "Mage bestial") { school-chart(school, class-weapon-profiles.filter(profile => profile.school == school)) }