// Craft portfolio analysis, separating observed counts from interpretation. #import "@preview/primaviz:0.6.0": grouped-bar-chart, horizontal-bar-chart #import "craft_metrics.typ": * #import "report_style.typ": chart-theme, metric-card, report-theme, rounded #import "../theme/tables.typ" as tables #import "../build_config.typ": craft-tiers, craft-trigram #import "weapon_report.typ": weapon-analysis-report #import "class_weapon_report.typ": class-weapon-report #import "weapon_breakpoint_report.typ": weapon-breakpoint-report #import "weapon_armor_report.typ": weapon-armor-report #import "defense_report.typ": defense-report #import "defense_metrics.typ": global-protection-efficiency-leader #import "craft_price_report.typ": craft-price-report #import "report_config.typ": chapter-enabled #let insight-card(label, value, note) = block( width: 100%, fill: report-theme.parchment, stroke: 0.6pt + report-theme.border, inset: 7pt, radius: 2pt, )[ #text( size: 6.5pt, tracking: 0.06em, weight: "bold", fill: report-theme.heading-subtle, )[ #upper(label) ] #v(2pt) #text(size: 9.5pt, weight: "bold", fill: report-theme.heading)[#value] #v(1pt) #text(size: 7pt, fill: report-theme.muted-ink)[#note] ] #let percentage(part, total) = if total == 0 { "0 %" } else { str(calc.round(100 * part / total, digits: 0)) + " %" } #let counted-list(items, count-key: "count", limit: 4) = ( items .slice( 0, calc.min(limit, items.len()), ) .map(item => item.label + " (" + str(item.at(count-key)) + ")") .join(", ") ) #let range-label(value) = if value == none { [—] } else { [#value.min–#value.max (#value.count)] } #let craft-summary() = { heading(level: 2)[Artisanat — Couverture élémentaire] grid( columns: (1fr,) * 4, column-gutter: 8pt, metric-card("Sources", craft-sources.len()), metric-card("Entrées", craft-entry-count()), metric-card("Mentions élémentaires", all-craft-mentions.len()), metric-card("Éléments distincts", element-counts().len()), ) [L’unité mesurée est une *mention fonctionnelle* d’un élément dans un effet : dégâts, résistance, accès ou autre interaction. Elle décrit la couverture du système, pas sa puissance brute. Un effet très fort et un effet mineur comptent donc chacun une fois.] heading(level: 3)[Fonctions élémentaires par artisanat] grouped-bar-chart( ( labels: craft-order, series: context-order.map(role => ( name: role, values: craft-order.map(craft => selected-mentions( craft: craft, role: role, ).len()), )), ), width: 100%, height: 205pt, theme: chart-theme, ) heading(level: 3)[Progression par tier] grouped-bar-chart( ( labels: craft-tiers.map(tier => "T" + str(tier)), series: ("Dégâts", "Résistance", "Accès").map(role => ( name: role, values: tier-counts(role: role).map(item => item.count), )), ), width: 100%, height: 180pt, theme: chart-theme, ) } #let element-coverage() = { pagebreak(weak: true) heading(level: 2)[Artisanat — Éléments représentés] let damage = ranked-elements("Dégâts") let resistance = ranked-elements("Résistance") grid( columns: (1fr, 1fr), column-gutter: 12pt, horizontal-bar-chart( ( labels: damage.map(item => item.label), values: damage.map(item => item.count), ), width: 100%, height: 235pt, title: [Mentions dans les dégâts], show-values: true, theme: chart-theme, ), horizontal-bar-chart( ( labels: resistance.map(item => item.label), values: resistance.map(item => item.count), ), width: 100%, height: 235pt, title: [Mentions dans les résistances], show-values: true, theme: chart-theme, ), ) heading(level: 3)[Matrice fonctionnelle] let rows = () for element in element-definitions { let values = context-order.map(role => selected-mentions( role: role, element: element.label, ).len()) if values.sum() > 0 { rows.push((element.label,) + values.map(str)) } } tables.set-table-style( table( columns: (1.5fr,) + (0.75fr,) * 4, align: (left,) + (right,) * 4, table.header([Élément], [Dégâts], [Résistance], [Accès], [Autre]), ..rows.flatten(), ), table-theme: "steingrund", text-size: 8pt, ) } #let mechanic-analysis() = { pagebreak(weak: true) heading(level: 2)[Artisanat — Effets et contraintes] [Les familles ci-dessous sont détectées dans les textes d’effet; R.Max, Torque et Accès élémentaire proviennent de leurs macros structurées dans tous les champs. Les moyennes de coût, niveau, toxicité et Finitions utilisent uniquement les lignes où le champ correspondant est présent. Le breakpoint est le tier dont l’augmentation par rapport au tier précédent est la plus forte.] heading(level: 3)[Volume par famille d’effet] horizontal-bar-chart( ( labels: mechanic-counts.map(item => item.label), values: mechanic-counts.map(item => item.count), ), width: 100%, height: 190pt, show-values: true, theme: chart-theme, ) heading(level: 3)[Contraintes moyennes et breakpoints] let rows = mechanic-profiles.map(profile => ( profile.category, str(profile.count), "T" + str(profile.first-tier), "T" + str(profile.peak-tier) + " (" + str(profile.peak-count) + ")", "T" + str(profile.breakpoint-tier) + " (" + if profile.breakpoint-increase >= 0 { "+" } else { "" } + str(profile.breakpoint-increase) + ")", rounded(profile.cost, digits: 1), rounded(profile.level, digits: 1), rounded(profile.toxicity, digits: 1), rounded(profile.endurance, digits: 1), )) tables.set-table-style( table( columns: ( 1.25fr, 0.38fr, 0.42fr, 0.72fr, 0.78fr, 0.48fr, 0.48fr, 0.48fr, 0.48fr, ), align: (left,) + (right,) * 8, table.header( [Famille], [N], [Début], [Pic], [Rupture], [Coût], [Niv.], [Tox.], [Finitions], ), ..rows.flatten(), ), table-theme: "steingrund", text-size: 7pt, ) let constrained = ("cost", "level", "toxicity", "endurance").map(key => { let available = mechanic-profiles .filter(profile => profile.at(key) != none) .sorted( key: profile => -profile.at(key), ) (key: key, leader: available.first()) }) grid( columns: (1fr,) * 4, column-gutter: 7pt, insight-card( "Coût max. moyen", constrained.at(0).leader.category + " · " + str(constrained.at(0).leader.cost), [maximum calculé entre familles], ), insight-card( "Niveau max. moyen", constrained.at(1).leader.category + " · " + str(constrained.at(1).leader.level), [maximum calculé entre familles], ), insight-card( "Toxicité max. moyenne", constrained.at(2).leader.category + " · " + str(constrained.at(2).leader.toxicity), [maximum calculé entre familles], ), insight-card( "Finitions moy. max.", constrained.at(3).leader.category + " · " + str(constrained.at(3).leader.endurance), [maximum calculé entre familles], ), ) pagebreak(weak: true) heading(level: 3)[Répartition par métier] let craft-rows = () for category in mechanic-order { craft-rows.push(category) for craft in craft-order { craft-rows.push(str( all-craft-mechanics .filter(item => ( item.category == category and item.craft == craft )) .len(), )) } } tables.set-table-style( table( columns: (1.4fr,) + (0.78fr,) * craft-order.len(), align: (left,) + (right,) * craft-order.len(), table.header([Famille], ..craft-order.map(craft-trigram)), ..craft-rows, ), table-theme: "steingrund", text-size: 7.5pt, ) heading(level: 3)[Étendue des contraintes] let range-rows = mechanic-order.map(category => { let records = selected-mechanics(category: category) ( category, range-label(range-present(records, "cost")), range-label(range-present(records, "level")), range-label(range-present(records, "toxicity")), range-label(range-present(records, "endurance")), ) }) tables.set-table-style( table( columns: (1.3fr, 1fr, 1fr, 1fr, 1fr), align: (left, right, right, right, right), table.header( [Famille], [Coût min–max], [Niv. min–max], [Tox. min–max], [Finitions min–max], ), ..range-rows.flatten(), ), table-theme: "steingrund", text-size: 7.2pt, ) heading(level: 3)[Contraintes moyennes par tier] let tier-rows = craft-tiers.map(tier => { let records = all-craft-mechanics.filter(item => item.tier == tier) ( "T" + str(tier), str(records.len()), rounded(average-present(records, "cost"), digits: 1), rounded(average-present(records, "level"), digits: 1), rounded(average-present(records, "toxicity"), digits: 1), rounded(average-present(records, "endurance"), digits: 1), ) }) tables.set-table-style( table( columns: (0.6fr, 0.6fr, 1fr, 1fr, 1fr, 1fr), align: (left, right, right, right, right, right), table.header( [Tier], [N], [Coût moy.], [Niv. moy.], [Tox. moy.], [Finitions moy.] ), ..tier-rows.flatten(), ), table-theme: "steingrund", text-size: 7.5pt, ) pagebreak(weak: true) heading(level: 3)[Altérations et marques] let alterations = subtype-counts("Altérations") let marks = subtype-counts("Marques") grid( columns: (1fr, 1fr), column-gutter: 12pt, horizontal-bar-chart( ( labels: alterations.map(item => item.label.replace("_", " ")), values: alterations.map(item => item.count), ), width: 100%, height: 255pt, title: [Altérations détectées], show-values: true, theme: chart-theme, ), horizontal-bar-chart( ( labels: marks.map(item => item.label.replace("_", " ")), values: marks.map(item => item.count), ), width: 100%, height: 150pt, title: [Marques détectées], show-values: true, theme: chart-theme, ), ) heading(level: 3)[Contraintes des altérations les plus fréquentes] let subtype-rows = alterations .slice(0, calc.min(12, alterations.len())) .map(item => { let profile = subtype-profile("Altérations", item.label) ( item.label.replace("_", " "), str(profile.count), "T" + str(profile.first-tier), "T" + str(profile.peak-tier), rounded(profile.cost, digits: 1), rounded(profile.level, digits: 1), rounded(profile.toxicity, digits: 1), ) }) tables.set-table-style( table( columns: (1.4fr, 0.45fr, 0.55fr, 0.55fr, 0.7fr, 0.7fr, 0.7fr), align: (left,) + (right,) * 6, table.header([Altération], [N], [Début], [Pic], [Coût], [Niv.], [Tox.]), ..subtype-rows.flatten(), ), table-theme: "steingrund", text-size: 7pt, ) heading(level: 3)[Contraintes des marques] let mark-rows = marks.map(item => { let profile = subtype-profile("Marques", item.label) ( item.label.replace("_", " "), str(profile.count), "T" + str(profile.first-tier), "T" + str(profile.peak-tier), rounded(profile.cost, digits: 1), rounded(profile.level, digits: 1), rounded(profile.toxicity, digits: 1), ) }) tables.set-table-style( table( columns: (1.4fr, 0.45fr, 0.55fr, 0.55fr, 0.7fr, 0.7fr, 0.7fr), align: (left,) + (right,) * 6, table.header([Marque], [N], [Début], [Pic], [Coût], [Niv.], [Tox.]), ..mark-rows.flatten(), ), table-theme: "steingrund", text-size: 7pt, ) heading(level: 3)[Progression automatique par tier] let progression-rows = () for profile in mechanic-profiles { progression-rows.push(profile.category) for tier in mechanic-tier-counts(profile.category) { progression-rows.push(str(tier.count)) } } tables.set-table-style( table( columns: (1.45fr,) + (0.6fr,) * craft-tiers.len(), align: (left,) + (right,) * craft-tiers.len(), table.header([Famille], ..craft-tiers.map(tier => [T#tier])), ..progression-rows, ), table-theme: "steingrund", text-size: 7.5pt, ) pagebreak(weak: true) heading(level: 3)[Références aux règles et caractéristiques] [Cette couche est exhaustive: chaque occurrence de `@rl_*` et `@ca_*` dans les champs et valeurs analysés est comptée, même lorsqu’aucune heuristique spécifique n’existe encore pour la macro. Les en-têtes-macros sont comptés une fois par entrée, comme les autres variables de données.] horizontal-bar-chart( ( labels: rule-reference-counts.map(item => item.label), values: rule-reference-counts.map(item => item.count), ), width: 100%, height: 220pt, show-values: true, x-label: [Occurrences], theme: chart-theme, ) let reference-rows = rule-reference-counts.map(item => ( item.label, [@#item.macro], str(item.count), item.crafts.join(", "), if item.first-tier == none { [—] } else { str(item.first-tier) }, if item.last-tier == none { [—] } else { str(item.last-tier) }, )) tables.set-table-style( table( columns: (1.35fr, 1fr, 0.45fr, 1.25fr, 0.5fr, 0.5fr), align: (left, left, right, left, right, right), table.header([Effet], [Macro], [N], [Artisanats], [T. min], [T. max]), ..reference-rows.flatten(), ), table-theme: "steingrund", text-size: 7.2pt, ) } #let battle-plan() = { pagebreak(weak: true) heading(level: 2)[Artisanat — Plan de bataille] let damage = ranked-elements("Dégâts") let resistance = ranked-elements("Résistance") let damage-gaps = coverage-gap("Dégâts", "Résistance") let resistance-gaps = coverage-gap("Résistance", "Dégâts") let damage-crafts = ranked-crafts("Dégâts") let resistance-crafts = ranked-crafts("Résistance") let access-crafts = ranked-crafts("Accès") let damage-tiers = ranked-tiers("Dégâts") let resistance-tiers = ranked-tiers("Résistance") let damage-total = selected-mentions(role: "Dégâts").len() let resistance-total = selected-mentions(role: "Résistance").len() let access-total = selected-mentions(role: "Accès").len() let versatile = versatile-elements [Cette page ne formule aucune recommandation manuelle. Chaque signal est calculé à partir des mentions détectées ; il mesure la disponibilité des options, pas leur puissance numérique.] heading(level: 3)[Abondance et polyvalence] grid( columns: (1fr, 1fr), column-gutter: 12pt, row-gutter: 10pt, insight-card( "Axes offensifs abondants", counted-list(damage), [nombre de mentions de dégâts], ), insight-card( "Défenses abondantes", counted-list(resistance), [nombre de mentions de résistance], ), insight-card( "Éléments polyvalents", counted-list(versatile, count-key: "overlap"), [minimum commun entre dégâts et résistance], ), insight-card( "Accès disponibles", counted-list(ranked-elements("Accès")), [nombre de mentions donnant accès à l’élément], ), ) heading(level: 3)[Concentration par métier] grid( columns: (1fr, 1fr, 1fr, 1fr), column-gutter: 10pt, insight-card( "Dégâts", counted-list(damage-crafts, limit: 2), [leader : #percentage(damage-crafts.first().count, damage-total) du total], ), insight-card( "Résistances", counted-list(resistance-crafts, limit: 2), [leader : #percentage(resistance-crafts.first().count, resistance-total) du total], ), insight-card( "Accès", counted-list(access-crafts, limit: 2), [leader : #percentage(access-crafts.first().count, access-total) du total], ), insight-card( "Diversité", counted-list(ranked-craft-breadth, limit: 2), [nombre d’éléments distincts par métier], ), ) heading(level: 3)[Fenêtres de disponibilité] grid( columns: (1fr, 1fr), column-gutter: 12pt, row-gutter: 10pt, insight-card( "Pic offensif", "Tier " + str(damage-tiers.first().tier), [#damage-tiers.first().count mentions de dégâts], ), insight-card( "Pic défensif", "Tier " + str(resistance-tiers.first().tier), [#resistance-tiers.first().count mentions de résistance], ), ) heading(level: 3)[Couverture asymétrique] grid( columns: (1fr, 1fr), column-gutter: 12pt, row-gutter: 10pt, insight-card( "Sans résistance détectée", if damage-gaps.len() == 0 { "Aucun" } else { damage-gaps.join(", ") }, [éléments présents en dégâts seulement], ), insight-card( "Sans dégâts détectés", if resistance-gaps.len() == 0 { "Aucun" } else { resistance-gaps.join(", ") }, [éléments présents en résistance seulement], ), ) heading(level: 3)[Sélection d’équipement] let efficiency = global-protection-efficiency-leader grid( columns: (1fr,), row-gutter: 10pt, insight-card( "Protection par torque", efficiency.name, [#calc.round(efficiency.protection / efficiency.torque, digits: 2) protection / torque · #efficiency.protection protection pour #efficiency.torque torque], ), ) } #let craft-audit() = { pagebreak() heading(level: 2)[Artisanat — Audit des mentions] let rows = all-craft-mentions.map(mention => ( 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), table.header( [Métier], [Source], [Entrée], [T.], [Rôle], [Élément], [Segment détecté] ), ..rows.flatten(), ), table-theme: "steingrund", text-size: 5.9pt, ) heading(level: 3)[Audit des références `@rl_*` et `@ca_*`] let reference-rows = all-craft-rule-references.map(reference => ( reference.craft, reference.dataset, reference.item, if reference.tier == none { [—] } else { str(reference.tier) }, [@#reference.macro], reference.field, reference.raw, )) tables.set-table-style( table( columns: (0.58fr, 0.68fr, 1fr, 0.28fr, 0.75fr, 0.9fr, 1.8fr), table.header( [Métier], [Source], [Entrée], [T.], [Macro], [Champ], [Valeur source] ), ..reference-rows.flatten(), ), table-theme: "steingrund", text-size: 5.9pt, ) } #let render-craft-report() = { pagebreak() heading(level: 1)[Artisanat] if chapter-enabled("craft.summary") { craft-summary() } if chapter-enabled("craft.prices") { craft-price-report() } 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.weapons.classes") { class-weapon-report() } if chapter-enabled("craft.defenses") { defense-report() } if chapter-enabled("craft.audit") { craft-audit() } }