archvillainette
59c8e407e9
Reviewed-on: https://gitea.westgate.pw/ShadowsOverWestgate/sow-tools/pulls/13 Co-authored-by: vickydotbat <vickydotbat@tutamail.com> Co-committed-by: vickydotbat <vickydotbat@tutamail.com>
416 lines
14 KiB
Go
416 lines
14 KiB
Go
package topdata
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
type wikiDataProvidersDocument struct {
|
|
Providers map[string]wikiDataProviderDefinition `json:"providers" yaml:"providers"`
|
|
}
|
|
|
|
type wikiDataProviderDefinition struct {
|
|
Source string `json:"source" yaml:"source"`
|
|
Levels string `json:"levels" yaml:"levels"`
|
|
ClassFeats wikiDataProviderClassFeatConfig `json:"class_feats" yaml:"class_feats"`
|
|
Attacks wikiDataProviderAttacksConfig `json:"attacks" yaml:"attacks"`
|
|
Provider string `json:"provider" yaml:"provider"`
|
|
Columns int `json:"columns" yaml:"columns"`
|
|
ItemsPerColumn int `json:"items_per_column" yaml:"items_per_column"`
|
|
ForceColumns bool `json:"force_columns" yaml:"force_columns"`
|
|
}
|
|
|
|
type wikiDataProviderClassFeatConfig struct {
|
|
Fields map[string]wikiDataProviderProjectionField `json:"fields" yaml:"fields"`
|
|
}
|
|
|
|
type wikiDataProviderProjectionField struct {
|
|
When string `json:"when" yaml:"when"`
|
|
}
|
|
|
|
type wikiDataProviderAttacksConfig struct {
|
|
Field string `json:"field" yaml:"field"`
|
|
CountField string `json:"count_field" yaml:"count_field"`
|
|
Mode string `json:"mode" yaml:"mode"`
|
|
Step int `json:"step" yaml:"step"`
|
|
Attacks int `json:"attacks" yaml:"attacks"`
|
|
Thresholds []wikiDataProviderAttackThreshold `json:"thresholds" yaml:"thresholds"`
|
|
Overrides []wikiDataProviderAttackOverrideRule `json:"overrides" yaml:"overrides"`
|
|
}
|
|
|
|
type wikiDataProviderAttackThreshold struct {
|
|
MinBAB int `json:"min_bab" yaml:"min_bab"`
|
|
Attacks int `json:"attacks" yaml:"attacks"`
|
|
}
|
|
|
|
type wikiDataProviderAttackOverrideRule struct {
|
|
Classes []string `json:"classes" yaml:"classes"`
|
|
Levels any `json:"levels" yaml:"levels"`
|
|
Attacks int `json:"attacks" yaml:"attacks"`
|
|
Add int `json:"add" yaml:"add"`
|
|
}
|
|
|
|
func loadWikiDataProviders(path string) (map[string]wikiDataProviderDefinition, error) {
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return map[string]wikiDataProviderDefinition{}, nil
|
|
}
|
|
return nil, fmt.Errorf("read wiki data providers %s: %w", path, err)
|
|
}
|
|
var doc wikiDataProvidersDocument
|
|
if err := yaml.Unmarshal(raw, &doc); err != nil {
|
|
return nil, fmt.Errorf("parse wiki data providers %s: %w", path, err)
|
|
}
|
|
for name, def := range doc.Providers {
|
|
if strings.TrimSpace(name) == "" {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider name must not be empty", path)
|
|
}
|
|
if strings.TrimSpace(def.Source) == "" {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s missing source", path, name)
|
|
}
|
|
source := strings.TrimSpace(def.Source)
|
|
switch source {
|
|
case "class_progression":
|
|
for field, projection := range def.ClassFeats.Fields {
|
|
if strings.TrimSpace(field) == "" {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s has class feat projection without field name", path, name)
|
|
}
|
|
if strings.TrimSpace(projection.When) == "" {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s class feat projection %s missing when", path, name, field)
|
|
}
|
|
}
|
|
if err := validateWikiDataProviderAttacks(path, name, def.Attacks); err != nil {
|
|
return nil, err
|
|
}
|
|
case "columns":
|
|
if len(def.ClassFeats.Fields) > 0 {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s class feat projections require source class_progression", path, name)
|
|
}
|
|
if strings.TrimSpace(def.Attacks.Mode) != "" {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s attacks config requires source class_progression", path, name)
|
|
}
|
|
if strings.TrimSpace(def.Provider) == "" {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s columns provider missing provider", path, name)
|
|
}
|
|
if strings.TrimSpace(def.Provider) == name {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s columns provider must not reference itself", path, name)
|
|
}
|
|
if def.Columns <= 0 {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s columns must be a positive integer", path, name)
|
|
}
|
|
if def.ItemsPerColumn <= 0 {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s items_per_column must be a positive integer", path, name)
|
|
}
|
|
case "class_feats", "class_skills", "class_summary", "class_spellbook", "race_feats", "race_name_forms":
|
|
if len(def.ClassFeats.Fields) > 0 {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s class feat projections require source class_progression", path, name)
|
|
}
|
|
if strings.TrimSpace(def.Attacks.Mode) != "" {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s attacks config requires source class_progression", path, name)
|
|
}
|
|
default:
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s has unknown source %q", path, name, def.Source)
|
|
}
|
|
}
|
|
for name, def := range doc.Providers {
|
|
if strings.TrimSpace(def.Source) != "columns" {
|
|
continue
|
|
}
|
|
if _, ok := doc.Providers[strings.TrimSpace(def.Provider)]; !ok {
|
|
return nil, fmt.Errorf("wiki data providers %s: provider %s columns provider references missing provider %q", path, name, def.Provider)
|
|
}
|
|
}
|
|
if doc.Providers == nil {
|
|
return map[string]wikiDataProviderDefinition{}, nil
|
|
}
|
|
return doc.Providers, nil
|
|
}
|
|
|
|
func (ctx *wikiContext) wikiDataProviderRows(name string, page wikiTemplatePage) ([]map[string]any, error) {
|
|
def, ok := ctx.wikiDataProviders[name]
|
|
if !ok {
|
|
return nil, fmt.Errorf("missing wiki data provider %q in %s", name, ctx.wikiDataPath)
|
|
}
|
|
switch strings.TrimSpace(def.Source) {
|
|
case "columns":
|
|
sourceRows, err := ctx.wikiDataProviderRows(strings.TrimSpace(def.Provider), page)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return wikiColumnProviderRows(sourceRows, def.Columns, def.ItemsPerColumn, def.ForceColumns), nil
|
|
case "class_progression":
|
|
if page.Category != "classes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.classProgressionRows(def.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 "class_skills":
|
|
if page.Category != "classes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.classSkillRows(page.Row), nil
|
|
case "class_summary":
|
|
if page.Category != "classes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.classSummaryRows(page.Row), nil
|
|
case "class_spellbook":
|
|
if page.Category != "classes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.classSpellbookRows(page.Key, page.Row), nil
|
|
case "race_feats":
|
|
if page.Category != "racialtypes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.raceFeatRows(page.Row), nil
|
|
case "race_name_forms":
|
|
if page.Category != "racialtypes" {
|
|
return nil, nil
|
|
}
|
|
return ctx.raceNameFormRows(page.Row), nil
|
|
default:
|
|
return nil, fmt.Errorf("unknown wiki data provider source %q", def.Source)
|
|
}
|
|
}
|
|
|
|
func validateWikiDataProviderAttacks(path, provider string, cfg wikiDataProviderAttacksConfig) error {
|
|
if strings.TrimSpace(cfg.Mode) == "" {
|
|
return nil
|
|
}
|
|
switch strings.TrimSpace(cfg.Mode) {
|
|
case "fixed":
|
|
if cfg.Attacks < 1 {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks fixed mode requires positive attacks", path, provider)
|
|
}
|
|
case "bab_thresholds":
|
|
if len(cfg.Thresholds) == 0 {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks bab_thresholds mode requires thresholds", path, provider)
|
|
}
|
|
for i, threshold := range cfg.Thresholds {
|
|
if threshold.MinBAB < 0 {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks threshold %d min_bab must be non-negative", path, provider, i+1)
|
|
}
|
|
if threshold.Attacks < 1 {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks threshold %d attacks must be positive", path, provider, i+1)
|
|
}
|
|
}
|
|
default:
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks has unknown mode %q", path, provider, cfg.Mode)
|
|
}
|
|
for i, override := range cfg.Overrides {
|
|
if len(override.Classes) == 0 {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks override %d missing classes", path, provider, i+1)
|
|
}
|
|
for _, class := range override.Classes {
|
|
if strings.TrimSpace(class) == "" {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks override %d has empty class", path, provider, i+1)
|
|
}
|
|
}
|
|
if _, err := parseWikiAttackLevels(override.Levels); err != nil {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks override %d bad levels: %w", path, provider, i+1, err)
|
|
}
|
|
if override.Attacks != 0 && override.Add != 0 {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks override %d must not set both attacks and add", path, provider, i+1)
|
|
}
|
|
if override.Attacks == 0 && override.Add == 0 {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks override %d must set attacks or add", path, provider, i+1)
|
|
}
|
|
if override.Attacks < 0 {
|
|
return fmt.Errorf("wiki data providers %s: provider %s attacks override %d attacks must be positive", path, provider, i+1)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func parseWikiAttackLevels(raw any) (map[int]struct{}, error) {
|
|
out := map[int]struct{}{}
|
|
addLevel := func(value any) error {
|
|
switch typed := value.(type) {
|
|
case int:
|
|
if typed < 1 {
|
|
return fmt.Errorf("level must be positive")
|
|
}
|
|
out[typed] = struct{}{}
|
|
return nil
|
|
case int64:
|
|
if typed < 1 {
|
|
return fmt.Errorf("level must be positive")
|
|
}
|
|
out[int(typed)] = struct{}{}
|
|
return nil
|
|
case float64:
|
|
level := int(typed)
|
|
if typed != float64(level) || level < 1 {
|
|
return fmt.Errorf("level must be a positive integer")
|
|
}
|
|
out[level] = struct{}{}
|
|
return nil
|
|
case string:
|
|
text := strings.TrimSpace(typed)
|
|
if text == "" {
|
|
return fmt.Errorf("level must not be empty")
|
|
}
|
|
if strings.Contains(text, "-") {
|
|
start, end, err := parseLevelRange(text)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for level := start; level <= end; level++ {
|
|
out[level] = struct{}{}
|
|
}
|
|
return nil
|
|
}
|
|
level, err := strconv.Atoi(text)
|
|
if err != nil || level < 1 {
|
|
return fmt.Errorf("level must be a positive integer")
|
|
}
|
|
out[level] = struct{}{}
|
|
return nil
|
|
default:
|
|
return fmt.Errorf("unsupported level value")
|
|
}
|
|
}
|
|
switch typed := raw.(type) {
|
|
case nil:
|
|
return nil, fmt.Errorf("levels is required")
|
|
case []any:
|
|
if len(typed) == 0 {
|
|
return nil, fmt.Errorf("levels must not be empty")
|
|
}
|
|
for _, value := range typed {
|
|
if err := addLevel(value); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
default:
|
|
if err := addLevel(raw); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func wikiColumnProviderRows(sourceRows []map[string]any, configuredColumns, itemsPerColumn int, forceColumns bool) []map[string]any {
|
|
if configuredColumns <= 0 || itemsPerColumn <= 0 {
|
|
return nil
|
|
}
|
|
needed := 0
|
|
if len(sourceRows) > 0 {
|
|
needed = (len(sourceRows) + itemsPerColumn - 1) / itemsPerColumn
|
|
}
|
|
total := needed
|
|
if forceColumns && configuredColumns > total {
|
|
total = configuredColumns
|
|
}
|
|
if total == 0 {
|
|
return nil
|
|
}
|
|
rows := make([]map[string]any, 0, total)
|
|
for i := 0; i < total; i++ {
|
|
start := i * itemsPerColumn
|
|
end := start + itemsPerColumn
|
|
if start > len(sourceRows) {
|
|
start = len(sourceRows)
|
|
}
|
|
if end > len(sourceRows) {
|
|
end = len(sourceRows)
|
|
}
|
|
items := make([]map[string]any, 0, end-start)
|
|
for _, source := range sourceRows[start:end] {
|
|
items = append(items, cloneRowMap(source))
|
|
}
|
|
rows = append(rows, map[string]any{
|
|
"Index": i + 1,
|
|
"Count": len(items),
|
|
"Items": items,
|
|
})
|
|
}
|
|
return rows
|
|
}
|
|
|
|
func (ctx *wikiContext) classSkillRows(classRow map[string]any) []map[string]any {
|
|
table := ctx.tableForValue(fieldValue(classRow, "SkillsTable"), ctx.classSkillTables)
|
|
if table == nil {
|
|
return nil
|
|
}
|
|
rows := []map[string]any{}
|
|
for _, source := range table.Rows {
|
|
if stringValue(source, "ClassSkill") != "1" {
|
|
continue
|
|
}
|
|
key := resolveReferenceKey(fieldValue(source, "SkillIndex"), ctx.skillIDToKey)
|
|
if key == "" {
|
|
key = resolveReferenceKey(fieldValue(source, "SkillIndex"), nil)
|
|
}
|
|
if key == "" || !ctx.canReferenceWikiKey(key) {
|
|
continue
|
|
}
|
|
row := cloneRowMap(source)
|
|
row["SkillKey"] = key
|
|
row["SkillName"] = ctx.resolveSkillName(key)
|
|
rows = append(rows, row)
|
|
}
|
|
return rows
|
|
}
|
|
|
|
func (ctx *wikiContext) raceFeatRows(raceRow map[string]any) []map[string]any {
|
|
values := []any{}
|
|
switch typed := fieldValue(raceRow, "FeatsTable").(type) {
|
|
case []any:
|
|
values = append(values, typed...)
|
|
case []string:
|
|
for _, value := range typed {
|
|
values = append(values, value)
|
|
}
|
|
default:
|
|
if table := ctx.tableForValue(typed, ctx.raceFeatTables); table != nil {
|
|
for _, row := range table.Rows {
|
|
values = append(values, fieldValue(row, "FeatIndex"))
|
|
}
|
|
}
|
|
}
|
|
rows := []map[string]any{}
|
|
for _, value := range values {
|
|
key := resolveReferenceKey(value, ctx.featIDToKey)
|
|
if key == "" {
|
|
key = resolveReferenceKey(value, nil)
|
|
}
|
|
if key == "" || !ctx.canReferenceWikiKey(key) {
|
|
continue
|
|
}
|
|
rows = append(rows, map[string]any{
|
|
"FeatKey": key,
|
|
"FeatName": ctx.resolveFeatName(key),
|
|
})
|
|
}
|
|
return rows
|
|
}
|
|
|
|
func (ctx *wikiContext) raceNameFormRows(raceRow map[string]any) []map[string]any {
|
|
candidates := []struct {
|
|
label string
|
|
field string
|
|
}{
|
|
{"Plural", "NamePlural"},
|
|
{"Converted Name", "ConverName"},
|
|
{"Lower Name", "ConverNameLower"},
|
|
}
|
|
rows := []map[string]any{}
|
|
for _, candidate := range candidates {
|
|
if value := ctx.resolveTextValue(fieldValue(raceRow, candidate.field), nil); value != "" {
|
|
rows = append(rows, map[string]any{"Label": candidate.label, "Value": value})
|
|
}
|
|
}
|
|
return rows
|
|
}
|