path: root/internal/behavior/store.go

package behavior

import (
	"fmt"
	"math/rand"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"sync"

	"gopkg.in/yaml.v3"
)

// excludedContentPath reports whether path lies under a directory or file
// whose name starts with "_", relative to root. That is the project's
// convention for work-in-progress content that must not be loaded, validated,
// indexed, or published while a builder is still authoring it.
func excludedContentPath(root, path string) bool {
	rel, err := filepath.Rel(root, path)
	if err != nil {
		return false
	}
	for _, part := range strings.Split(rel, string(os.PathSeparator)) {
		if strings.HasPrefix(part, "_") {
			return true
		}
	}
	return false
}

func BuildPathIndex(dir string) map[string]string {
	index := make(map[string]string)
	filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
		if err != nil || d.IsDir() {
			return nil
		}
		id, ok := yamlID(d.Name())
		if !ok {
			return nil
		}
		if excludedContentPath(dir, path) {
			return nil
		}
		index[id] = path
		return nil
	})
	return index
}

func BuildRoomIndex(dir string) map[int]string {
	index := make(map[int]string)
	filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
		if err != nil || d.IsDir() {
			return nil
		}
		id, ok := yamlID(d.Name())
		if !ok {
			return nil
		}
		if excludedContentPath(dir, path) {
			return nil
		}
		n, convErr := strconv.Atoi(id)
		if convErr != nil {
			// A non-numeric filename (for example a "1001_copy.yaml"
			// backup) must never shadow a real room via a numeric prefix;
			// skip it here and let validation flag it.
			return nil
		}
		// Room IDs are positive; every other code path treats <= 0 as "no
		// room". A 0.yaml/-1.yaml must not become a real room.
		if n <= 0 {
			return nil
		}
		index[n] = path
		return nil
	})
	return index
}

func WalkYAMLDir(dir string, fn func(path, id string, data []byte) error) error {
	return filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
		if err != nil {
			// A missing root is an empty tree; any other walk error (for
			// example an unreadable directory) must surface instead of
			// silently validating nothing.
			if os.IsNotExist(err) {
				return nil
			}
			return err
		}
		if d.IsDir() {
			return nil
		}
		id, ok := yamlID(d.Name())
		if !ok {
			return nil
		}
		if excludedContentPath(dir, path) {
			return nil
		}
		data, readErr := os.ReadFile(path)
		if readErr != nil {
			if os.IsNotExist(readErr) {
				return nil
			}
			return readErr
		}
		return fn(path, id, data)
	})
}

// yamlID returns the id (filename without extension) for a .yaml or .yml file.
// The runtime trigger loader accepts .yml, so validation discovery must too,
// otherwise such a file loads and fires while every check ignores it.
func yamlID(name string) (string, bool) {
	if strings.HasSuffix(name, ".yaml") {
		return strings.TrimSuffix(name, ".yaml"), true
	}
	if strings.HasSuffix(name, ".yml") {
		return strings.TrimSuffix(name, ".yml"), true
	}
	return "", false
}

type Duplicate struct {
	ID    string
	Paths []string
}

func CheckDuplicateIDs(dir string) []Duplicate {
	seen := make(map[string][]string)
	filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
		if err != nil || d.IsDir() {
			return nil
		}
		id, ok := yamlID(d.Name())
		if !ok {
			return nil
		}
		if excludedContentPath(dir, path) {
			return nil
		}
		seen[id] = append(seen[id], path)
		return nil
	})
	var dups []Duplicate
	for id, paths := range seen {
		if len(paths) > 1 {
			dups = append(dups, Duplicate{ID: id, Paths: paths})
		}
	}
	return dups
}

func SuccessChance(cfg SuccessFormula, level int, requiredLevel int) float64 {
	chance := cfg.Base + float64(level-requiredLevel)*cfg.PerLevel
	if chance > cfg.Cap {
		chance = cfg.Cap
	}
	if chance < 0 {
		chance = 0
	}
	return chance
}

var (
	dropIndexes = map[string]map[string]string{}
	dropIndexMu sync.Mutex
)

func loadDropIndex(dataDir string) map[string]string {
	dropIndexMu.Lock()
	defer dropIndexMu.Unlock()
	// Keyed by dataDir: a single process can host more than one data dir
	// (tests), and a shared index would resolve ids against the first one.
	if idx, ok := dropIndexes[dataDir]; ok {
		return idx
	}
	idx := BuildPathIndex(filepath.Join(dataDir, "drops"))
	dropIndexes[dataDir] = idx
	return idx
}

func ClearDropIndex() {
	dropIndexMu.Lock()
	defer dropIndexMu.Unlock()
	dropIndexes = map[string]map[string]string{}
}

func LoadDropTable(dataDir, id string) (*DropTableDef, error) {
	index := loadDropIndex(dataDir)
	path, ok := index[id]
	if !ok {
		if id == "" || strings.Contains(id, "..") || strings.ContainsAny(id, `/\`) {
			return nil, fmt.Errorf("invalid drop table id %q", id)
		}
		path = filepath.Join(dataDir, "drops", id+".yaml")
	}
	data, err := os.ReadFile(path)
	if err != nil {
		return nil, fmt.Errorf("read drop table %s: %w", id, err)
	}
	var dt DropTableDef
	if err := yaml.Unmarshal(data, &dt); err != nil {
		return nil, fmt.Errorf("parse drop table %s: %w", id, err)
	}
	return &dt, nil
}

// pickWeighted returns a single entry chosen by weight, without resolving any
// table reference on it. Returns nil if the list is empty or has no weight.
func pickWeighted(drops []DropEntry) *DropEntry {
	if len(drops) == 0 {
		return nil
	}
	total := 0
	for _, d := range drops {
		total += d.Weight
	}
	if total <= 0 {
		return nil
	}
	roll := rand.Intn(total)
	cumulative := 0
	for i := range drops {
		cumulative += drops[i].Weight
		if roll < cumulative {
			return &drops[i]
		}
	}
	return &drops[0]
}

// maxDropTableDepth bounds sub-table recursion. A self- or mutual-reference
// in authored drop tables would otherwise recurse until the goroutine stack
// is exhausted (an unrecoverable fatal error); the validator also rejects
// cycles at startup.
const maxDropTableDepth = 32

// maxDropRolls bounds a table-reference entry's `quantity` (how many times the
// referenced table is rolled). An accidental large value would run that many
// weighted picks on the owner tick and stall the whole world.
const maxDropRolls = 64

func ResolveDrop(dataDir string, drops []DropEntry) *DropEntry {
	return resolveDrop(dataDir, drops, 0)
}

func resolveDrop(dataDir string, drops []DropEntry, depth int) *DropEntry {
	if depth > maxDropTableDepth {
		return nil
	}
	picked := pickWeighted(drops)
	if picked == nil {
		return nil
	}
	if picked.Table != "" {
		sub, err := LoadDropTable(dataDir, picked.Table)
		if err != nil {
			return nil
		}
		resolved := resolveDrop(dataDir, sub.Drops, depth+1)
		if resolved == nil {
			return nil
		}
		qty := picked.Quantity
		if qty <= 0 {
			qty = resolved.Quantity
		}
		if qty <= 0 {
			qty = 1
		}
		return &DropEntry{
			ItemID:         resolved.ItemID,
			Quantity:       qty,
			Depletes:       picked.Depletes,
			SuccessMessage: picked.SuccessMessage,
			Tool:           picked.Tool,
			Level:          picked.Level,
			XP:             picked.XP,
		}
	}
	return picked
}

// ResolveDropList performs one weighted pick from drops. A plain item entry
// yields a single result. When the picked entry references a sub-table, its
// Quantity is treated as the number of INDEPENDENT rolls against that sub-table
// (default 1) — each roll may produce a different item — and all results are
// returned. Tables are just weighted lists of items; this is skill-independent.
func ResolveDropList(dataDir string, drops []DropEntry) []DropEntry {
	return resolveDropList(dataDir, drops, 0)
}

func resolveDropList(dataDir string, drops []DropEntry, depth int) []DropEntry {
	if depth > maxDropTableDepth {
		return nil
	}
	picked := pickWeighted(drops)
	if picked == nil {
		return nil
	}
	if picked.Table == "" {
		return []DropEntry{*picked}
	}
	sub, err := LoadDropTable(dataDir, picked.Table)
	if err != nil {
		return nil
	}
	rolls := picked.Quantity
	if rolls <= 0 {
		rolls = 1
	}
	// Bound authored quantities: an accidental `quantity: 1000000000` on a
	// table reference would otherwise run a billion weighted picks on the
	// owner tick and stall the whole world.
	if rolls > maxDropRolls {
		rolls = maxDropRolls
	}
	var out []DropEntry
	for i := 0; i < rolls; i++ {
		if resolved := resolveDrop(dataDir, sub.Drops, depth+1); resolved != nil && resolved.ItemID != "" {
			out = append(out, *resolved)
		}
	}
	return out
}