1506 lines
41 KiB
Go
1506 lines
41 KiB
Go
package topdata
|
|
|
|
import (
|
|
"fmt"
|
|
"html"
|
|
"os"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"unicode"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
type wikiTableDefinitionsDocument struct {
|
|
Tables map[string]wikiTableDefinition `json:"tables" yaml:"tables"`
|
|
}
|
|
|
|
type wikiTableDefinition struct {
|
|
Source string `json:"source" yaml:"source"`
|
|
Class string `json:"class" yaml:"class"`
|
|
When string `json:"when" yaml:"when"`
|
|
Rows wikiTableRowsConfig `json:"rows" yaml:"rows"`
|
|
ClassFeats wikiDataProviderClassFeatConfig `json:"class_feats" yaml:"class_feats"`
|
|
Attacks wikiDataProviderAttacksConfig `json:"attacks" yaml:"attacks"`
|
|
Columns []wikiTableColumn `json:"columns" yaml:"columns"`
|
|
}
|
|
|
|
type wikiTableRowsConfig struct {
|
|
Levels string `json:"levels" yaml:"levels"`
|
|
When string `json:"when" yaml:"when"`
|
|
}
|
|
|
|
type wikiTableColumn struct {
|
|
Key string `json:"key" yaml:"key"`
|
|
Label string `json:"label" yaml:"label"`
|
|
Value string `json:"value" yaml:"value"`
|
|
Empty string `json:"empty" yaml:"empty"`
|
|
Class string `json:"class" yaml:"class"`
|
|
Style string `json:"style" yaml:"style"`
|
|
HeaderClass string `json:"header_class" yaml:"header_class"`
|
|
HeaderStyle string `json:"header_style" yaml:"header_style"`
|
|
AllowWikiMarkup bool `json:"allow_wiki_markup" yaml:"allow_wiki_markup"`
|
|
When string `json:"when" yaml:"when"`
|
|
Children []wikiTableColumn `json:"children" yaml:"children"`
|
|
}
|
|
|
|
type wikiTableRenderContext struct {
|
|
Page wikiTemplatePage
|
|
TableName string
|
|
Path string
|
|
}
|
|
|
|
func loadWikiTableDefinitions(path string) (map[string]wikiTableDefinition, error) {
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return map[string]wikiTableDefinition{}, nil
|
|
}
|
|
return nil, fmt.Errorf("read wiki table definitions %s: %w", path, err)
|
|
}
|
|
return parseWikiTableDefinitions(raw, path)
|
|
}
|
|
|
|
func parseWikiTableDefinitions(raw []byte, path string) (map[string]wikiTableDefinition, error) {
|
|
var doc wikiTableDefinitionsDocument
|
|
if err := yaml.Unmarshal(raw, &doc); err != nil {
|
|
return nil, fmt.Errorf("parse wiki table definitions %s: %w", path, err)
|
|
}
|
|
if len(doc.Tables) == 0 {
|
|
return map[string]wikiTableDefinition{}, nil
|
|
}
|
|
for name, def := range doc.Tables {
|
|
if strings.TrimSpace(def.Source) == "" {
|
|
return nil, fmt.Errorf("wiki table definitions %s: table %s missing source", path, name)
|
|
}
|
|
if strings.TrimSpace(def.Source) != "class_progression" {
|
|
if len(def.ClassFeats.Fields) > 0 {
|
|
return nil, fmt.Errorf("wiki table definitions %s: table %s class feat projections require source class_progression", path, name)
|
|
}
|
|
if strings.TrimSpace(def.Attacks.Mode) != "" {
|
|
return nil, fmt.Errorf("wiki table definitions %s: table %s attacks config requires source class_progression", path, name)
|
|
}
|
|
}
|
|
if strings.TrimSpace(def.Source) == "class_progression" {
|
|
for field, projection := range def.ClassFeats.Fields {
|
|
if strings.TrimSpace(field) == "" {
|
|
return nil, fmt.Errorf("wiki table definitions %s: table %s has class feat projection without field name", path, name)
|
|
}
|
|
if strings.TrimSpace(projection.When) == "" {
|
|
return nil, fmt.Errorf("wiki table definitions %s: table %s class feat projection %s missing when", path, name, field)
|
|
}
|
|
}
|
|
if err := validateWikiDataProviderAttacks(path, name, def.Attacks); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if len(def.Columns) == 0 {
|
|
return nil, fmt.Errorf("wiki table definitions %s: table %s missing columns", path, name)
|
|
}
|
|
for _, col := range def.Columns {
|
|
if err := validateWikiTableColumn(path, name, col); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
return doc.Tables, nil
|
|
}
|
|
|
|
func validateWikiTableColumn(path, tableName string, col wikiTableColumn) error {
|
|
if strings.TrimSpace(col.Key) == "" {
|
|
return fmt.Errorf("wiki table definitions %s: table %s has column without key", path, tableName)
|
|
}
|
|
if strings.TrimSpace(col.Value) != "" && len(col.Children) > 0 {
|
|
return fmt.Errorf("wiki table definitions %s: table %s column %s cannot have both value and children", path, tableName, col.Key)
|
|
}
|
|
for _, child := range col.Children {
|
|
if err := validateWikiTableColumn(path, tableName, child); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ctx *wikiContext) renderConfiguredWikiTable(templatePath, tableName string, page wikiTemplatePage) (string, error) {
|
|
def, ok := ctx.wikiTableDefinitions[tableName]
|
|
if !ok {
|
|
return "", fmt.Errorf("render wiki template %s for %s: missing table definition %q in %s", templatePath, page.PageID, tableName, ctx.wikiTablesPath)
|
|
}
|
|
renderCtx := wikiTableRenderContext{Page: page, TableName: tableName, Path: ctx.wikiTablesPath}
|
|
if strings.TrimSpace(def.When) != "" {
|
|
value, err := ctx.evalWikiTableTemplate(def.When, page.Row, renderCtx)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if !truthyWikiTableValue(value) {
|
|
return "", nil
|
|
}
|
|
}
|
|
rows, err := ctx.wikiTableSourceRows(def, page)
|
|
if err != nil {
|
|
return "", fmt.Errorf("render wiki table %s for %s: %w", tableName, page.PageID, err)
|
|
}
|
|
if strings.TrimSpace(def.Rows.When) != "" {
|
|
filtered := rows[:0]
|
|
for _, row := range rows {
|
|
value, err := ctx.evalWikiTableTemplate(def.Rows.When, row, renderCtx)
|
|
if err != nil {
|
|
return "", fmt.Errorf("render wiki table %s for %s row condition %q: %w", tableName, page.PageID, def.Rows.When, err)
|
|
}
|
|
if truthyWikiTableValue(value) {
|
|
filtered = append(filtered, row)
|
|
}
|
|
}
|
|
rows = filtered
|
|
}
|
|
if len(rows) == 0 {
|
|
return "", nil
|
|
}
|
|
columns := visibleWikiTableColumns(def.Columns, aggregateWikiTableVisibilityRow(rows), ctx, renderCtx)
|
|
if len(columns) == 0 {
|
|
return "", nil
|
|
}
|
|
headerRows, leaves := buildWikiTableHeaders(columns)
|
|
if len(leaves) == 0 {
|
|
return "", nil
|
|
}
|
|
var out strings.Builder
|
|
class := strings.TrimSpace(def.Class)
|
|
if class != "" {
|
|
out.WriteString(`<table class="` + html.EscapeString(class) + `">`)
|
|
} else {
|
|
out.WriteString("<table>")
|
|
}
|
|
out.WriteString("\n <thead>\n")
|
|
for _, headerRow := range headerRows {
|
|
out.WriteString(" <tr>")
|
|
for _, cell := range headerRow {
|
|
out.WriteString(cell)
|
|
}
|
|
out.WriteString("</tr>\n")
|
|
}
|
|
out.WriteString(" </thead>\n <tbody>\n")
|
|
for _, row := range rows {
|
|
out.WriteString(" <tr>")
|
|
for _, col := range leaves {
|
|
cell, err := ctx.renderWikiTableCell(col, row, renderCtx)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
out.WriteString(cell)
|
|
}
|
|
out.WriteString("</tr>\n")
|
|
}
|
|
out.WriteString(" </tbody>\n</table>")
|
|
return out.String(), nil
|
|
}
|
|
|
|
func visibleWikiTableColumns(columns []wikiTableColumn, row map[string]any, ctx *wikiContext, renderCtx wikiTableRenderContext) []wikiTableColumn {
|
|
out := []wikiTableColumn{}
|
|
for _, col := range columns {
|
|
if strings.TrimSpace(col.When) != "" {
|
|
value, err := ctx.evalWikiTableTemplate(col.When, row, renderCtx)
|
|
if err != nil || !truthyWikiTableValue(value) {
|
|
continue
|
|
}
|
|
}
|
|
if len(col.Children) > 0 {
|
|
col.Children = visibleWikiTableColumns(col.Children, row, ctx, renderCtx)
|
|
if len(col.Children) == 0 {
|
|
continue
|
|
}
|
|
}
|
|
out = append(out, col)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func aggregateWikiTableVisibilityRow(rows []map[string]any) map[string]any {
|
|
out := map[string]any{}
|
|
for _, row := range rows {
|
|
for key, value := range row {
|
|
if _, exists := out[key]; exists {
|
|
continue
|
|
}
|
|
if truthyWikiTableValue(value) {
|
|
out[key] = value
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
type wikiTableHeaderCell struct {
|
|
HTML string
|
|
}
|
|
|
|
func buildWikiTableHeaders(columns []wikiTableColumn) ([][]string, []wikiTableColumn) {
|
|
hasGroups := false
|
|
for _, col := range columns {
|
|
if len(col.Children) > 0 {
|
|
hasGroups = true
|
|
break
|
|
}
|
|
}
|
|
first := []string{}
|
|
second := []string{}
|
|
leaves := []wikiTableColumn{}
|
|
for _, col := range columns {
|
|
label := html.EscapeString(defaultStringValue(col.Label, col.Key))
|
|
headerClass := attrClass(col.HeaderClass)
|
|
headerStyle := attrStyle(col.HeaderStyle)
|
|
if len(col.Children) == 0 {
|
|
leaves = append(leaves, col)
|
|
rowspan := ""
|
|
if hasGroups {
|
|
rowspan = ` rowspan="2"`
|
|
}
|
|
first = append(first, `<th scope="col"`+rowspan+headerClass+headerStyle+`>`+label+`</th>`)
|
|
continue
|
|
}
|
|
childLeaves := leafWikiTableColumns(col.Children)
|
|
first = append(first, `<th scope="colgroup" colspan="`+strconv.Itoa(len(childLeaves))+`"`+headerClass+headerStyle+`>`+label+`</th>`)
|
|
for _, child := range col.Children {
|
|
childLabel := html.EscapeString(defaultStringValue(child.Label, child.Key))
|
|
second = append(second, `<th scope="col"`+attrClass(child.HeaderClass)+attrStyle(child.HeaderStyle)+`>`+childLabel+`</th>`)
|
|
}
|
|
leaves = append(leaves, childLeaves...)
|
|
}
|
|
if hasGroups {
|
|
return [][]string{first, second}, leaves
|
|
}
|
|
return [][]string{first}, leaves
|
|
}
|
|
|
|
func leafWikiTableColumns(columns []wikiTableColumn) []wikiTableColumn {
|
|
out := []wikiTableColumn{}
|
|
for _, col := range columns {
|
|
if len(col.Children) == 0 {
|
|
out = append(out, col)
|
|
continue
|
|
}
|
|
out = append(out, leafWikiTableColumns(col.Children)...)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (ctx *wikiContext) renderWikiTableCell(col wikiTableColumn, row map[string]any, renderCtx wikiTableRenderContext) (string, error) {
|
|
value, err := ctx.evalWikiTableTemplate(col.Value, row, renderCtx)
|
|
if err != nil {
|
|
return "", fmt.Errorf("render wiki table %s for %s column %s expression %q: %w", renderCtx.TableName, renderCtx.Page.PageID, col.Key, col.Value, err)
|
|
}
|
|
text := stringifyWikiTableValue(value)
|
|
if strings.TrimSpace(text) == "" {
|
|
text = col.Empty
|
|
}
|
|
if !col.AllowWikiMarkup {
|
|
text = html.EscapeString(text)
|
|
}
|
|
return `<td` + attrClass(col.Class) + attrStyle(col.Style) + `>` + text + `</td>`, nil
|
|
}
|
|
|
|
func attrClass(class string) string {
|
|
class = strings.TrimSpace(class)
|
|
if class == "" {
|
|
return ""
|
|
}
|
|
return ` class="` + html.EscapeString(class) + `"`
|
|
}
|
|
|
|
func attrStyle(style string) string {
|
|
style = strings.TrimSpace(style)
|
|
if style == "" {
|
|
return ""
|
|
}
|
|
return ` style="` + html.EscapeString(style) + `"`
|
|
}
|
|
|
|
func defaultStringValue(value, fallback string) string {
|
|
if strings.TrimSpace(value) != "" {
|
|
return value
|
|
}
|
|
return fallback
|
|
}
|
|
|
|
func (ctx *wikiContext) wikiTableSourceRows(def wikiTableDefinition, page wikiTemplatePage) ([]map[string]any, error) {
|
|
switch strings.TrimSpace(def.Source) {
|
|
case "class_progression":
|
|
if page.Category != "classes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.classProgressionRows(def.Rows.Levels, def.ClassFeats.Fields, def.Attacks, page.Key, page.Row)
|
|
case "class_feats":
|
|
if page.Category != "classes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.classFeatRows(page.Row), nil
|
|
case "spell_progression":
|
|
if page.Category != "classes" {
|
|
return nil, nil
|
|
}
|
|
if !hasSpellProgression(page.Row) {
|
|
return nil, nil
|
|
}
|
|
return []map[string]any{}, nil
|
|
case "class_summary":
|
|
if page.Category != "classes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.classSummaryRows(page.Row), nil
|
|
default:
|
|
return nil, fmt.Errorf("unknown source %q", def.Source)
|
|
}
|
|
}
|
|
|
|
func (ctx *wikiContext) classProgressionRows(levels string, projections map[string]wikiDataProviderProjectionField, attacks wikiDataProviderAttacksConfig, classKey string, classRow map[string]any) ([]map[string]any, error) {
|
|
start, end, err := parseLevelRange(levels)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
saveRows := map[string]map[string]any{}
|
|
if table := ctx.tableForValue(fieldValue(classRow, "SavingThrowTable"), ctx.classSaveTables); table != nil {
|
|
for _, row := range table.Rows {
|
|
level := stringValue(row, "Level")
|
|
if level != "" {
|
|
saveRows[level] = row
|
|
}
|
|
}
|
|
}
|
|
if len(projections) == 0 {
|
|
projections = map[string]wikiDataProviderProjectionField{
|
|
"GrantedFeats": {When: "{{GrantedOnLevel > 0}}"},
|
|
}
|
|
}
|
|
classFeatFields := map[string]map[int][]string{}
|
|
for field := range projections {
|
|
classFeatFields[field] = map[int][]string{}
|
|
}
|
|
if table := ctx.tableForValue(fieldValue(classRow, "FeatsTable"), ctx.classFeatTables); table != nil {
|
|
for _, featRow := range table.Rows {
|
|
level, err := strconv.Atoi(stringValue(featRow, "GrantedOnLevel"))
|
|
if err != nil || level < start || level > end {
|
|
continue
|
|
}
|
|
name := ctx.renderReference(fieldValue(featRow, "FeatIndex"), ctx.featIDToKey, ctx.resolveFeatName)
|
|
if name == "" {
|
|
continue
|
|
}
|
|
renderCtx := wikiTableRenderContext{TableName: "class_progression", Path: ctx.wikiDataPath}
|
|
for field, projection := range projections {
|
|
value, err := ctx.evalWikiTableTemplate(projection.When, featRow, renderCtx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("class progression field %s condition %q: %w", field, projection.When, err)
|
|
}
|
|
if truthyWikiTableValue(value) {
|
|
classFeatFields[field][level] = append(classFeatFields[field][level], name)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bonusByLevel := map[int]string{}
|
|
if table := ctx.tableForValue(fieldValue(classRow, "BonusFeatsTable"), ctx.classBonusTables); table != nil {
|
|
for _, bonusRow := range table.Rows {
|
|
level, err := asInt(fieldValue(bonusRow, "id"))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
bonusByLevel[level] = stringValue(bonusRow, "Bonus")
|
|
}
|
|
}
|
|
hitDie, _ := asInt(fieldValue(classRow, "HitDie"))
|
|
spellsPerDayByLevel := classSpellProgressionByLevel(ctx.tableForValue(fieldValue(classRow, "SpellGainTable"), ctx.classSpellGainTables))
|
|
spellsKnownByLevel := classSpellProgressionByLevel(ctx.tableForValue(fieldValue(classRow, "SpellKnownTable"), ctx.classSpellKnownTables))
|
|
hasPerDay := hasClassSpellProgressionTable(classRow, ctx.classSpellGainTables, "SpellGainTable")
|
|
hasKnown := hasClassSpellProgressionTable(classRow, ctx.classSpellKnownTables, "SpellKnownTable")
|
|
out := []map[string]any{}
|
|
for level := start; level <= end; level++ {
|
|
row := cloneRowMap(classRow)
|
|
row["Level"] = level
|
|
bab := classBABAtLevel(stringValue(classRow, "AttackBonusTable"), level)
|
|
row["BABValue"] = bab
|
|
row["BAB"] = formatSignedInt(bab)
|
|
attackCount := classAttackCount(attacks, classKey, bab, level)
|
|
if attackCount < 1 {
|
|
attackCount = 1
|
|
}
|
|
countField := defaultStringValue(attacks.CountField, "AttackCount")
|
|
sequenceField := defaultStringValue(attacks.Field, "AttackSequence")
|
|
row[countField] = attackCount
|
|
row[sequenceField] = formatAttackSequence(bab, attackCount, attackStep(attacks))
|
|
if saveRow := saveRows[strconv.Itoa(level)]; saveRow != nil {
|
|
for key, value := range saveRow {
|
|
row[key] = value
|
|
}
|
|
}
|
|
for field, values := range classFeatFields {
|
|
row[field] = values[level]
|
|
}
|
|
row["BonusFeat"] = bonusByLevel[level]
|
|
row["HPMin"] = level
|
|
if hitDie > 0 {
|
|
row["HPMax"] = level * hitDie
|
|
}
|
|
row["Notes"] = ""
|
|
row["HasSpellProgression"] = hasSpellProgression(classRow)
|
|
row["HasSpellsPerDay"] = hasPerDay
|
|
row["HasSpellsKnown"] = hasKnown
|
|
populateClassSpellProgressionFields(row, "SpellsPerDay", spellsPerDayByLevel[level])
|
|
populateClassSpellProgressionFields(row, "SpellsKnown", spellsKnownByLevel[level])
|
|
out = append(out, row)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func classSpellProgressionByLevel(table *wikiTable) map[int]map[int]string {
|
|
out := map[int]map[int]string{}
|
|
if table == nil {
|
|
return out
|
|
}
|
|
for _, tableRow := range table.Rows {
|
|
level, err := asInt(fieldValue(tableRow, "Level"))
|
|
if err != nil || level < 1 {
|
|
continue
|
|
}
|
|
values := map[int]string{}
|
|
for key, value := range tableRow {
|
|
if !strings.HasPrefix(key, "SpellLevel") {
|
|
continue
|
|
}
|
|
spellLevel, err := strconv.Atoi(strings.TrimPrefix(key, "SpellLevel"))
|
|
if err != nil || spellLevel < 0 {
|
|
continue
|
|
}
|
|
values[spellLevel] = stringifyWikiTableValue(value)
|
|
}
|
|
out[level] = values
|
|
}
|
|
return out
|
|
}
|
|
|
|
func populateClassSpellProgressionFields(row map[string]any, prefix string, values map[int]string) {
|
|
ordered := []string{}
|
|
for _, spellLevel := range sortedIntMapKeys(values) {
|
|
value := values[spellLevel]
|
|
row[prefix+strconv.Itoa(spellLevel)] = value
|
|
ordered = append(ordered, value)
|
|
}
|
|
row[prefix+"ByLevel"] = ordered
|
|
}
|
|
|
|
func sortedIntMapKeys(values map[int]string) []int {
|
|
keys := make([]int, 0, len(values))
|
|
for key := range values {
|
|
keys = append(keys, key)
|
|
}
|
|
slices.Sort(keys)
|
|
return keys
|
|
}
|
|
|
|
func parseLevelRange(raw string) (int, int, error) {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return 1, 20, nil
|
|
}
|
|
if !strings.Contains(raw, "-") {
|
|
level, err := strconv.Atoi(raw)
|
|
if err != nil || level < 1 {
|
|
return 0, 0, fmt.Errorf("bad row range %q", raw)
|
|
}
|
|
return level, level, nil
|
|
}
|
|
left, right, _ := strings.Cut(raw, "-")
|
|
start, err1 := strconv.Atoi(strings.TrimSpace(left))
|
|
end, err2 := strconv.Atoi(strings.TrimSpace(right))
|
|
if err1 != nil || err2 != nil || start < 1 || end < start {
|
|
return 0, 0, fmt.Errorf("bad row range %q", raw)
|
|
}
|
|
return start, end, nil
|
|
}
|
|
|
|
func classBABAtLevel(table string, level int) int {
|
|
switch strings.ToLower(strings.TrimSpace(table)) {
|
|
case "cls_atk_1":
|
|
return level
|
|
case "cls_atk_2":
|
|
return (level * 3) / 4
|
|
case "cls_atk_3":
|
|
return level / 2
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func classAttackCount(cfg wikiDataProviderAttacksConfig, classKey string, bab, level int) int {
|
|
count := baseClassAttackCount(cfg, bab)
|
|
for _, override := range cfg.Overrides {
|
|
if !wikiAttackOverrideMatches(override, classKey, level) {
|
|
continue
|
|
}
|
|
if override.Attacks > 0 {
|
|
count = override.Attacks
|
|
continue
|
|
}
|
|
count += override.Add
|
|
}
|
|
if count < 1 {
|
|
return 1
|
|
}
|
|
return count
|
|
}
|
|
|
|
func baseClassAttackCount(cfg wikiDataProviderAttacksConfig, bab int) int {
|
|
switch strings.TrimSpace(cfg.Mode) {
|
|
case "fixed":
|
|
if cfg.Attacks > 0 {
|
|
return cfg.Attacks
|
|
}
|
|
case "bab_thresholds":
|
|
return attackCountFromThresholds(cfg.Thresholds, bab)
|
|
case "":
|
|
return attackCountFromThresholds(defaultWikiAttackThresholds(), bab)
|
|
}
|
|
return 1
|
|
}
|
|
|
|
func attackCountFromThresholds(thresholds []wikiDataProviderAttackThreshold, bab int) int {
|
|
count := 1
|
|
for _, threshold := range thresholds {
|
|
if threshold.Attacks > 0 && bab >= threshold.MinBAB {
|
|
count = threshold.Attacks
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
func defaultWikiAttackThresholds() []wikiDataProviderAttackThreshold {
|
|
return []wikiDataProviderAttackThreshold{
|
|
{MinBAB: 1, Attacks: 1},
|
|
{MinBAB: 6, Attacks: 2},
|
|
{MinBAB: 11, Attacks: 3},
|
|
{MinBAB: 16, Attacks: 4},
|
|
}
|
|
}
|
|
|
|
func wikiAttackOverrideMatches(override wikiDataProviderAttackOverrideRule, classKey string, level int) bool {
|
|
foundClass := false
|
|
for _, candidate := range override.Classes {
|
|
if strings.TrimSpace(candidate) == classKey {
|
|
foundClass = true
|
|
break
|
|
}
|
|
}
|
|
if !foundClass {
|
|
return false
|
|
}
|
|
levels, err := parseWikiAttackLevels(override.Levels)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
_, ok := levels[level]
|
|
return ok
|
|
}
|
|
|
|
func attackStep(cfg wikiDataProviderAttacksConfig) int {
|
|
if cfg.Step == 0 {
|
|
return -5
|
|
}
|
|
return cfg.Step
|
|
}
|
|
|
|
func formatAttackSequence(bab, attacks, step int) string {
|
|
if attacks < 1 {
|
|
attacks = 1
|
|
}
|
|
values := make([]string, 0, attacks)
|
|
current := bab
|
|
for i := 0; i < attacks; i++ {
|
|
values = append(values, formatSignedInt(current))
|
|
current += step
|
|
}
|
|
return strings.Join(values, "/")
|
|
}
|
|
|
|
func formatSignedInt(value int) string {
|
|
if value > 0 {
|
|
return "+" + strconv.Itoa(value)
|
|
}
|
|
return strconv.Itoa(value)
|
|
}
|
|
|
|
func (ctx *wikiContext) classFeatRows(classRow map[string]any) []map[string]any {
|
|
table := ctx.tableForValue(fieldValue(classRow, "FeatsTable"), ctx.classFeatTables)
|
|
if table == nil {
|
|
return nil
|
|
}
|
|
out := []map[string]any{}
|
|
for _, source := range table.Rows {
|
|
row := cloneRowMap(source)
|
|
key := resolveReferenceKey(fieldValue(source, "FeatIndex"), ctx.featIDToKey)
|
|
if key == "" {
|
|
key = resolveReferenceKey(fieldValue(source, "FeatIndex"), nil)
|
|
}
|
|
row["FeatKey"] = key
|
|
row["FeatName"] = ctx.resolveFeatName(key)
|
|
out = append(out, row)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (ctx *wikiContext) classSummaryRows(classRow map[string]any) []map[string]any {
|
|
return []map[string]any{
|
|
{"Label": "Hit Die", "Value": "d" + stringValue(classRow, "HitDie")},
|
|
{"Label": "Skill Points", "Value": stringValue(classRow, "SkillPointBase")},
|
|
{"Label": "Primary Ability", "Value": stringValue(classRow, "PrimaryAbil")},
|
|
}
|
|
}
|
|
|
|
func isClassSpellcaster(row map[string]any) bool {
|
|
return stringValue(row, "SpellCaster") == "1"
|
|
}
|
|
|
|
func hasSpellProgression(row map[string]any) bool {
|
|
return isClassSpellcaster(row) && (hasTableReference(fieldValue(row, "SpellGainTable")) || hasTableReference(fieldValue(row, "SpellKnownTable")))
|
|
}
|
|
|
|
func hasClassSpellProgressionTable(row map[string]any, tables map[string]wikiTable, field string) bool {
|
|
return isClassSpellcaster(row) && ctxHasTableValue(row, tables, field)
|
|
}
|
|
|
|
func hasTableReference(value any) bool {
|
|
switch typed := value.(type) {
|
|
case string:
|
|
return strings.TrimSpace(typed) != "" && strings.TrimSpace(typed) != nullValue
|
|
case map[string]any:
|
|
tableKey, _ := typed["table"].(string)
|
|
return strings.TrimSpace(tableKey) != ""
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func ctxHasTableValue(row map[string]any, tables map[string]wikiTable, field string) bool {
|
|
switch value := fieldValue(row, field).(type) {
|
|
case string:
|
|
if _, ok := tables[value]; ok {
|
|
return true
|
|
}
|
|
_, ok := tables[outputStem(value)]
|
|
return ok
|
|
case map[string]any:
|
|
tableKey, _ := value["table"].(string)
|
|
if tableKey == "" {
|
|
return false
|
|
}
|
|
if _, ok := tables[tableKey]; ok {
|
|
return true
|
|
}
|
|
_, ok := tables[outputStem(tableKey)]
|
|
return ok
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (ctx *wikiContext) classSpellbookRows(classKey string, classRow map[string]any) []map[string]any {
|
|
spec, ok := ctx.classSpellbooks[classKey]
|
|
if !ok || !ctx.hasClassSpellbook(classKey, classRow) {
|
|
return nil
|
|
}
|
|
out := []map[string]any{}
|
|
for _, level := range sortedIntKeys(spec.Levels) {
|
|
spells := ctx.renderClassSpellbookLevel(spec.Levels[level])
|
|
if len(spells) == 0 {
|
|
continue
|
|
}
|
|
out = append(out, map[string]any{
|
|
"SpellLevel": level,
|
|
"SpellLevelLabel": spellbookLevelLabel(level),
|
|
"Spells": spells,
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (ctx *wikiContext) hasClassSpellbook(classKey string, classRow map[string]any) bool {
|
|
if ctx == nil || !isClassSpellcaster(classRow) {
|
|
return false
|
|
}
|
|
spec, ok := ctx.classSpellbooks[classKey]
|
|
if !ok {
|
|
return false
|
|
}
|
|
for _, spells := range spec.Levels {
|
|
if len(spells) > 0 {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ctx *wikiContext) renderClassSpellbookLevel(spellKeys []string) []string {
|
|
type renderedSpell struct {
|
|
Name string
|
|
Link string
|
|
}
|
|
rendered := []renderedSpell{}
|
|
for _, spellKey := range spellKeys {
|
|
name := ctx.resolveSpellName(spellKey)
|
|
if name == "" {
|
|
name = spellKey
|
|
}
|
|
link := ctx.renderReference(map[string]any{"id": spellKey}, nil, ctx.resolveSpellName)
|
|
if link == "" {
|
|
continue
|
|
}
|
|
rendered = append(rendered, renderedSpell{Name: name, Link: link})
|
|
}
|
|
slices.SortFunc(rendered, func(a, b renderedSpell) int {
|
|
if cmp := strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name)); cmp != 0 {
|
|
return cmp
|
|
}
|
|
return strings.Compare(a.Link, b.Link)
|
|
})
|
|
out := make([]string, 0, len(rendered))
|
|
for _, spell := range rendered {
|
|
out = append(out, spell.Link)
|
|
}
|
|
return out
|
|
}
|
|
|
|
func spellbookLevelLabel(level int) string {
|
|
if level == 0 {
|
|
return "0-level spells"
|
|
}
|
|
return ordinalWikiTableValue(level) + "-level spells"
|
|
}
|
|
|
|
func (ctx *wikiContext) evalWikiTableTemplate(template string, row map[string]any, renderCtx wikiTableRenderContext) (any, error) {
|
|
template = strings.TrimSpace(template)
|
|
if strings.HasPrefix(template, "{{") && strings.HasSuffix(template, "}}") {
|
|
expr := strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(template, "{{"), "}}"))
|
|
return evalWikiTableExpression(expr, row, ctx, renderCtx)
|
|
}
|
|
if strings.Contains(template, "{{") {
|
|
return nil, fmt.Errorf("mixed literal/expression templates are not supported")
|
|
}
|
|
return template, nil
|
|
}
|
|
|
|
func evalWikiTableExpression(expr string, row map[string]any, ctx *wikiContext, renderCtx wikiTableRenderContext) (any, error) {
|
|
parser := wikiExprParser{tokens: tokenizeWikiExpr(expr), row: row, ctx: ctx, renderCtx: renderCtx}
|
|
value, err := parser.parseComparison()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if parser.peek().kind != wikiExprEOF {
|
|
return nil, fmt.Errorf("unexpected token %q", parser.peek().text)
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
type wikiExprTokenKind int
|
|
|
|
const (
|
|
wikiExprEOF wikiExprTokenKind = iota
|
|
wikiExprIdent
|
|
wikiExprString
|
|
wikiExprNumber
|
|
wikiExprLParen
|
|
wikiExprRParen
|
|
wikiExprComma
|
|
wikiExprPlus
|
|
wikiExprEq
|
|
wikiExprNE
|
|
wikiExprGT
|
|
wikiExprGE
|
|
wikiExprLT
|
|
wikiExprLE
|
|
wikiExprAnd
|
|
wikiExprOr
|
|
)
|
|
|
|
type wikiExprToken struct {
|
|
kind wikiExprTokenKind
|
|
text string
|
|
}
|
|
|
|
func tokenizeWikiExpr(expr string) []wikiExprToken {
|
|
tokens := []wikiExprToken{}
|
|
for i := 0; i < len(expr); {
|
|
r := rune(expr[i])
|
|
if unicode.IsSpace(r) {
|
|
i++
|
|
continue
|
|
}
|
|
switch expr[i] {
|
|
case '(':
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprLParen, text: "("})
|
|
i++
|
|
case ')':
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprRParen, text: ")"})
|
|
i++
|
|
case ',':
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprComma, text: ","})
|
|
i++
|
|
case '+':
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprPlus, text: "+"})
|
|
i++
|
|
case '>':
|
|
if i+1 < len(expr) && expr[i+1] == '=' {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprGE, text: ">="})
|
|
i += 2
|
|
} else {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprGT, text: ">"})
|
|
i++
|
|
}
|
|
case '<':
|
|
if i+1 < len(expr) && expr[i+1] == '=' {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprLE, text: "<="})
|
|
i += 2
|
|
} else {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprLT, text: "<"})
|
|
i++
|
|
}
|
|
case '!':
|
|
if i+1 < len(expr) && expr[i+1] == '=' {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprNE, text: "!="})
|
|
i += 2
|
|
} else {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprEOF, text: expr[i:]})
|
|
return tokens
|
|
}
|
|
case '&':
|
|
if i+1 < len(expr) && expr[i+1] == '&' {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprAnd, text: "&&"})
|
|
i += 2
|
|
} else {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprEOF, text: expr[i:]})
|
|
return tokens
|
|
}
|
|
case '|':
|
|
if i+1 < len(expr) && expr[i+1] == '|' {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprOr, text: "||"})
|
|
i += 2
|
|
} else {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprEOF, text: expr[i:]})
|
|
return tokens
|
|
}
|
|
case '=':
|
|
if i+1 < len(expr) && expr[i+1] == '=' {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprEq, text: "=="})
|
|
i += 2
|
|
} else {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprEOF, text: expr[i:]})
|
|
return tokens
|
|
}
|
|
case '"':
|
|
j := i + 1
|
|
var b strings.Builder
|
|
for ; j < len(expr); j++ {
|
|
if expr[j] == '\\' && j+1 < len(expr) {
|
|
j++
|
|
b.WriteByte(expr[j])
|
|
continue
|
|
}
|
|
if expr[j] == '"' {
|
|
break
|
|
}
|
|
b.WriteByte(expr[j])
|
|
}
|
|
if j >= len(expr) {
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprEOF, text: expr[i:]})
|
|
return tokens
|
|
}
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprString, text: b.String()})
|
|
i = j + 1
|
|
default:
|
|
if unicode.IsDigit(r) || expr[i] == '-' {
|
|
j := i + 1
|
|
for j < len(expr) && unicode.IsDigit(rune(expr[j])) {
|
|
j++
|
|
}
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprNumber, text: expr[i:j]})
|
|
i = j
|
|
continue
|
|
}
|
|
if unicode.IsLetter(r) || expr[i] == '_' {
|
|
j := i + 1
|
|
for j < len(expr) {
|
|
rr := rune(expr[j])
|
|
if !unicode.IsLetter(rr) && !unicode.IsDigit(rr) && expr[j] != '_' && expr[j] != '.' {
|
|
break
|
|
}
|
|
j++
|
|
}
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprIdent, text: expr[i:j]})
|
|
i = j
|
|
continue
|
|
}
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprEOF, text: expr[i:]})
|
|
return tokens
|
|
}
|
|
}
|
|
tokens = append(tokens, wikiExprToken{kind: wikiExprEOF})
|
|
return tokens
|
|
}
|
|
|
|
type wikiExprParser struct {
|
|
tokens []wikiExprToken
|
|
pos int
|
|
row map[string]any
|
|
ctx *wikiContext
|
|
renderCtx wikiTableRenderContext
|
|
allowMissingFields bool
|
|
}
|
|
|
|
func (p *wikiExprParser) peek() wikiExprToken {
|
|
if p.pos >= len(p.tokens) {
|
|
return wikiExprToken{kind: wikiExprEOF}
|
|
}
|
|
return p.tokens[p.pos]
|
|
}
|
|
|
|
func (p *wikiExprParser) take(kind wikiExprTokenKind) (wikiExprToken, bool) {
|
|
token := p.peek()
|
|
if token.kind != kind {
|
|
return token, false
|
|
}
|
|
p.pos++
|
|
return token, true
|
|
}
|
|
|
|
func (p *wikiExprParser) parseComparison() (any, error) {
|
|
return p.parseOr()
|
|
}
|
|
|
|
func (p *wikiExprParser) parseOr() (any, error) {
|
|
left, err := p.parseAnd()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for p.peek().kind == wikiExprOr {
|
|
p.pos++
|
|
right, err := p.parseAnd()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
left = truthyWikiTableValue(left) || truthyWikiTableValue(right)
|
|
}
|
|
return left, nil
|
|
}
|
|
|
|
func (p *wikiExprParser) parseAnd() (any, error) {
|
|
left, err := p.parseRelational()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for p.peek().kind == wikiExprAnd {
|
|
p.pos++
|
|
right, err := p.parseRelational()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
left = truthyWikiTableValue(left) && truthyWikiTableValue(right)
|
|
}
|
|
return left, nil
|
|
}
|
|
|
|
func (p *wikiExprParser) parseRelational() (any, error) {
|
|
left, err := p.parseConcat()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch p.peek().kind {
|
|
case wikiExprEq, wikiExprNE, wikiExprGT, wikiExprGE, wikiExprLT, wikiExprLE:
|
|
op := p.peek().kind
|
|
p.pos++
|
|
right, err := p.parseConcat()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
switch op {
|
|
case wikiExprEq:
|
|
return stringifyWikiTableValue(left) == stringifyWikiTableValue(right), nil
|
|
case wikiExprNE:
|
|
return stringifyWikiTableValue(left) != stringifyWikiTableValue(right), nil
|
|
case wikiExprGT:
|
|
return numericWikiTableValue(left) > numericWikiTableValue(right), nil
|
|
case wikiExprGE:
|
|
return numericWikiTableValue(left) >= numericWikiTableValue(right), nil
|
|
case wikiExprLT:
|
|
return numericWikiTableValue(left) < numericWikiTableValue(right), nil
|
|
case wikiExprLE:
|
|
return numericWikiTableValue(left) <= numericWikiTableValue(right), nil
|
|
}
|
|
return false, nil
|
|
default:
|
|
return left, nil
|
|
}
|
|
}
|
|
|
|
func (p *wikiExprParser) parseConcat() (any, error) {
|
|
left, err := p.parsePrimary()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for p.peek().kind == wikiExprPlus {
|
|
p.pos++
|
|
right, err := p.parsePrimary()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
left = stringifyWikiTableValue(left) + stringifyWikiTableValue(right)
|
|
}
|
|
return left, nil
|
|
}
|
|
|
|
func (p *wikiExprParser) parsePrimary() (any, error) {
|
|
token := p.peek()
|
|
switch token.kind {
|
|
case wikiExprString:
|
|
p.pos++
|
|
return token.text, nil
|
|
case wikiExprNumber:
|
|
p.pos++
|
|
value, err := strconv.Atoi(token.text)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid number %q", token.text)
|
|
}
|
|
return value, nil
|
|
case wikiExprIdent:
|
|
p.pos++
|
|
if p.peek().kind == wikiExprLParen {
|
|
p.pos++
|
|
args := []any{}
|
|
if p.peek().kind != wikiExprRParen {
|
|
previousAllowMissing := p.allowMissingFields
|
|
if wikiExprHelperAllowsMissingArgs(token.text) {
|
|
p.allowMissingFields = true
|
|
}
|
|
for {
|
|
arg, err := p.parseComparison()
|
|
if err != nil {
|
|
p.allowMissingFields = previousAllowMissing
|
|
return nil, err
|
|
}
|
|
args = append(args, arg)
|
|
if _, ok := p.take(wikiExprComma); !ok {
|
|
break
|
|
}
|
|
}
|
|
p.allowMissingFields = previousAllowMissing
|
|
}
|
|
if _, ok := p.take(wikiExprRParen); !ok {
|
|
return nil, fmt.Errorf("missing closing parenthesis for %s", token.text)
|
|
}
|
|
return p.callHelper(token.text, args)
|
|
}
|
|
return p.resolveField(token.text)
|
|
case wikiExprLParen:
|
|
p.pos++
|
|
value, err := p.parseComparison()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if _, ok := p.take(wikiExprRParen); !ok {
|
|
return nil, fmt.Errorf("missing closing parenthesis")
|
|
}
|
|
return value, nil
|
|
default:
|
|
return nil, fmt.Errorf("unexpected token %q", token.text)
|
|
}
|
|
}
|
|
|
|
func wikiExprHelperAllowsMissingArgs(name string) bool {
|
|
switch name {
|
|
case "present", "all_present", "any_present", "alignments":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (p *wikiExprParser) resolveField(name string) (any, error) {
|
|
name = strings.TrimPrefix(name, "row.")
|
|
if name == "HasSpellProgression" {
|
|
return hasSpellProgression(p.renderCtx.Page.Row), nil
|
|
}
|
|
if name == "HasSpellsPerDay" {
|
|
return hasClassSpellProgressionTable(p.renderCtx.Page.Row, p.ctx.classSpellGainTables, "SpellGainTable"), nil
|
|
}
|
|
if name == "HasSpellsKnown" {
|
|
return hasClassSpellProgressionTable(p.renderCtx.Page.Row, p.ctx.classSpellKnownTables, "SpellKnownTable"), nil
|
|
}
|
|
if name == "HasClassSpellbook" {
|
|
return p.ctx.hasClassSpellbook(p.renderCtx.Page.Key, p.renderCtx.Page.Row), nil
|
|
}
|
|
switch name {
|
|
case "true":
|
|
return true, nil
|
|
case "false":
|
|
return false, nil
|
|
}
|
|
if value, ok := lookupField(p.row, name); ok {
|
|
return value, nil
|
|
}
|
|
if value, ok := lookupField(p.renderCtx.Page.Row, name); ok {
|
|
return value, nil
|
|
}
|
|
if isClassSpellProgressionFieldName(name) {
|
|
return nil, nil
|
|
}
|
|
if p.allowMissingFields {
|
|
return nil, nil
|
|
}
|
|
return nil, fmt.Errorf("missing field %q", name)
|
|
}
|
|
|
|
func isClassSpellProgressionFieldName(name string) bool {
|
|
for _, prefix := range []string{"SpellsPerDay", "SpellsKnown"} {
|
|
suffix := strings.TrimPrefix(name, prefix)
|
|
if suffix == name || suffix == "ByLevel" || suffix == "" {
|
|
continue
|
|
}
|
|
if _, err := strconv.Atoi(suffix); err == nil {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (p *wikiExprParser) callHelper(name string, args []any) (any, error) {
|
|
switch name {
|
|
case "ordinal":
|
|
if len(args) != 1 {
|
|
return nil, fmt.Errorf("ordinal expects 1 argument")
|
|
}
|
|
return ordinalWikiTableValue(numericWikiTableValue(args[0])), nil
|
|
case "range":
|
|
if len(args) != 2 {
|
|
return nil, fmt.Errorf("range expects 2 arguments")
|
|
}
|
|
left := stringifyWikiTableValue(args[0])
|
|
right := stringifyWikiTableValue(args[1])
|
|
if left == "" || right == "" {
|
|
return "", nil
|
|
}
|
|
return left + "-" + right, nil
|
|
case "link":
|
|
if len(args) == 1 {
|
|
key := stringifyWikiTableValue(args[0])
|
|
if p.ctx != nil && !p.ctx.canReferenceWikiKey(key) {
|
|
return "", nil
|
|
}
|
|
if p.ctx != nil {
|
|
if target := p.ctx.publicWikiTargetForKey(key, ""); target != "" {
|
|
key = target
|
|
}
|
|
}
|
|
return "[[" + key + "]]", nil
|
|
}
|
|
if len(args) == 2 {
|
|
key := stringifyWikiTableValue(args[0])
|
|
label := stringifyWikiTableValue(args[1])
|
|
if key == "" {
|
|
return label, nil
|
|
}
|
|
if p.ctx != nil && !p.ctx.canReferenceWikiKey(key) {
|
|
return "", nil
|
|
}
|
|
if p.ctx != nil {
|
|
if target := p.ctx.publicWikiTargetForKey(key, label); target != "" {
|
|
key = target
|
|
}
|
|
}
|
|
return "[[" + key + "|" + label + "]]", nil
|
|
}
|
|
return nil, fmt.Errorf("link expects 1 or 2 arguments")
|
|
case "if":
|
|
if len(args) != 3 {
|
|
return nil, fmt.Errorf("if expects 3 arguments")
|
|
}
|
|
if truthyWikiTableValue(args[0]) {
|
|
return args[1], nil
|
|
}
|
|
return args[2], nil
|
|
case "join":
|
|
if len(args) != 2 {
|
|
return nil, fmt.Errorf("join expects 2 arguments")
|
|
}
|
|
sep := stringifyWikiTableValue(args[1])
|
|
switch typed := args[0].(type) {
|
|
case []string:
|
|
return strings.Join(typed, sep), nil
|
|
case []any:
|
|
parts := make([]string, 0, len(typed))
|
|
for _, value := range typed {
|
|
if text := stringifyWikiTableValue(value); text != "" {
|
|
parts = append(parts, text)
|
|
}
|
|
}
|
|
return strings.Join(parts, sep), nil
|
|
default:
|
|
return stringifyWikiTableValue(args[0]), nil
|
|
}
|
|
case "count":
|
|
if len(args) != 1 {
|
|
return nil, fmt.Errorf("count expects 1 argument")
|
|
}
|
|
return countWikiTemplateValue(args[0]), nil
|
|
case "nonzero":
|
|
if len(args) != 1 {
|
|
return nil, fmt.Errorf("nonzero expects 1 argument")
|
|
}
|
|
if numericWikiTableValue(args[0]) == 0 {
|
|
return "", nil
|
|
}
|
|
return args[0], nil
|
|
case "eq":
|
|
if len(args) != 2 {
|
|
return nil, fmt.Errorf("eq expects 2 arguments")
|
|
}
|
|
return stringifyWikiTableValue(args[0]) == stringifyWikiTableValue(args[1]), nil
|
|
case "field":
|
|
if len(args) != 1 {
|
|
return nil, fmt.Errorf("field expects 1 argument")
|
|
}
|
|
return p.resolveField(stringifyWikiTableValue(args[0]))
|
|
case "default":
|
|
if len(args) != 2 {
|
|
return nil, fmt.Errorf("default expects 2 arguments")
|
|
}
|
|
if strings.TrimSpace(stringifyWikiTableValue(args[0])) == "" {
|
|
return args[1], nil
|
|
}
|
|
return args[0], nil
|
|
case "present":
|
|
if len(args) != 1 {
|
|
return nil, fmt.Errorf("present expects 1 argument")
|
|
}
|
|
return presentWikiValue(args[0]), nil
|
|
case "all_present":
|
|
if len(args) == 0 {
|
|
return nil, fmt.Errorf("all_present expects at least 1 argument")
|
|
}
|
|
for _, value := range args {
|
|
if !presentWikiValue(value) {
|
|
return false, nil
|
|
}
|
|
}
|
|
return true, nil
|
|
case "any_present":
|
|
if len(args) == 0 {
|
|
return nil, fmt.Errorf("any_present expects at least 1 argument")
|
|
}
|
|
for _, value := range args {
|
|
if presentWikiValue(value) {
|
|
return true, nil
|
|
}
|
|
}
|
|
return false, nil
|
|
case "alignments":
|
|
if len(args) != 1 {
|
|
return nil, fmt.Errorf("alignments expects 1 argument")
|
|
}
|
|
return p.ctx.formatWikiTemplateAlignments(args[0])
|
|
case "yes_no":
|
|
if len(args) != 1 {
|
|
return nil, fmt.Errorf("yes_no expects 1 argument")
|
|
}
|
|
return yesNoValue(stringifyWikiTableValue(args[0])), nil
|
|
case "text":
|
|
if len(args) != 1 {
|
|
return nil, fmt.Errorf("text expects 1 argument")
|
|
}
|
|
return p.ctx.resolveTextValue(args[0], nil), nil
|
|
case "ref":
|
|
if len(args) != 2 {
|
|
return nil, fmt.Errorf("ref expects 2 arguments")
|
|
}
|
|
return p.ctx.renderReference(args[0], p.ctx.wikiIDMapForDataset(stringifyWikiTableValue(args[1])), p.ctx.wikiNameResolverForDataset(stringifyWikiTableValue(args[1]))), nil
|
|
case "feat_prerequisites":
|
|
if len(args) != 0 {
|
|
return nil, fmt.Errorf("feat_prerequisites expects 0 arguments")
|
|
}
|
|
return p.ctx.renderFeatPrerequisites(p.renderCtx.Page.Row), nil
|
|
case "required_feats":
|
|
if len(args) != 0 {
|
|
return nil, fmt.Errorf("required_feats expects 0 arguments")
|
|
}
|
|
return p.ctx.renderReferenceList(p.ctx.wikiReqFeats(p.renderCtx.Page.Row)), nil
|
|
case "ability_adjustments":
|
|
if len(args) != 0 {
|
|
return nil, fmt.Errorf("ability_adjustments expects 0 arguments")
|
|
}
|
|
return formatAbilityAdjustments(p.renderCtx.Page.Row), nil
|
|
case "hidden_ref":
|
|
if len(args) != 2 {
|
|
return nil, fmt.Errorf("hidden_ref expects 2 arguments")
|
|
}
|
|
hidden, err := p.hiddenWikiReference(args[0], stringifyWikiTableValue(args[1]))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return hidden, nil
|
|
case "all_hidden_refs":
|
|
if len(args) < 2 {
|
|
return nil, fmt.Errorf("all_hidden_refs expects at least 2 arguments")
|
|
}
|
|
targetDataset := stringifyWikiTableValue(args[len(args)-1])
|
|
checked := false
|
|
for _, value := range args[:len(args)-1] {
|
|
if !presentWikiValue(value) {
|
|
continue
|
|
}
|
|
checked = true
|
|
hidden, err := p.hiddenWikiReference(value, targetDataset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !hidden {
|
|
return false, nil
|
|
}
|
|
}
|
|
return checked, nil
|
|
default:
|
|
return nil, fmt.Errorf("unknown helper %q", name)
|
|
}
|
|
}
|
|
|
|
func countWikiTemplateValue(value any) int {
|
|
switch typed := value.(type) {
|
|
case nil:
|
|
return 0
|
|
case []string:
|
|
return len(typed)
|
|
case []any:
|
|
count := 0
|
|
for _, item := range typed {
|
|
if presentWikiValue(item) {
|
|
count++
|
|
}
|
|
}
|
|
return count
|
|
case map[string]any:
|
|
return len(typed)
|
|
default:
|
|
if presentWikiValue(value) {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func (p *wikiExprParser) hiddenWikiReference(value any, targetDataset string) (bool, error) {
|
|
targetDataset = strings.TrimSpace(targetDataset)
|
|
if !isWikiVisibilityDataset(targetDataset) {
|
|
return false, fmt.Errorf("unknown reference dataset %q", targetDataset)
|
|
}
|
|
if !presentWikiValue(value) {
|
|
return false, nil
|
|
}
|
|
if p.ctx == nil {
|
|
return false, nil
|
|
}
|
|
key := resolveReferenceKey(value, p.ctx.wikiIDMapForDataset(targetDataset))
|
|
if key == "" {
|
|
return true, nil
|
|
}
|
|
if !strings.HasPrefix(key, targetDataset+":") {
|
|
return true, nil
|
|
}
|
|
return !p.ctx.canReferenceWikiKey(key), nil
|
|
}
|
|
|
|
func presentWikiValue(value any) bool {
|
|
if isNullLike(value) {
|
|
return false
|
|
}
|
|
if text, ok := value.(string); ok {
|
|
return strings.TrimSpace(text) != ""
|
|
}
|
|
return value != nil
|
|
}
|
|
|
|
func ordinalWikiTableValue(value int) string {
|
|
suffix := "th"
|
|
if value%100 < 11 || value%100 > 13 {
|
|
switch value % 10 {
|
|
case 1:
|
|
suffix = "st"
|
|
case 2:
|
|
suffix = "nd"
|
|
case 3:
|
|
suffix = "rd"
|
|
}
|
|
}
|
|
return strconv.Itoa(value) + suffix
|
|
}
|
|
|
|
func stringifyWikiTableValue(value any) string {
|
|
switch typed := value.(type) {
|
|
case nil:
|
|
return ""
|
|
case string:
|
|
if typed == nullValue {
|
|
return ""
|
|
}
|
|
return typed
|
|
case bool:
|
|
if typed {
|
|
return "true"
|
|
}
|
|
return ""
|
|
case int:
|
|
return strconv.Itoa(typed)
|
|
case float64:
|
|
return strconv.Itoa(int(typed))
|
|
case []string:
|
|
return strings.Join(typed, ", ")
|
|
case []any:
|
|
parts := make([]string, 0, len(typed))
|
|
for _, value := range typed {
|
|
if text := stringifyWikiTableValue(value); text != "" {
|
|
parts = append(parts, text)
|
|
}
|
|
}
|
|
return strings.Join(parts, ", ")
|
|
default:
|
|
return fmt.Sprint(typed)
|
|
}
|
|
}
|
|
|
|
func numericWikiTableValue(value any) int {
|
|
switch typed := value.(type) {
|
|
case int:
|
|
return typed
|
|
case float64:
|
|
return int(typed)
|
|
case string:
|
|
parsed, _ := strconv.Atoi(strings.TrimSpace(typed))
|
|
return parsed
|
|
default:
|
|
parsed, _ := strconv.Atoi(strings.TrimSpace(stringifyWikiTableValue(value)))
|
|
return parsed
|
|
}
|
|
}
|
|
|
|
func truthyWikiTableValue(value any) bool {
|
|
switch typed := value.(type) {
|
|
case bool:
|
|
return typed
|
|
case nil:
|
|
return false
|
|
case string:
|
|
trimmed := strings.TrimSpace(strings.ToLower(typed))
|
|
return trimmed != "" && trimmed != "0" && trimmed != "false" && trimmed != nullValue
|
|
case int:
|
|
return typed != 0
|
|
case float64:
|
|
return typed != 0
|
|
default:
|
|
return strings.TrimSpace(stringifyWikiTableValue(value)) != ""
|
|
}
|
|
}
|