zenno: title and favicon

This includes modifying horsebot to use the generated JSON, as well as
moving the generator to another cmd/ directory.

Remove the generated code while we're here.
Koka tests still have to be updated, but it requires a JSON parser.

cmd/horsebot/main.go

@@ -3,12 +3,17 @@ package main
 import (
 	"bytes"
 	"context"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
 	"log/slog"
+	"net"
+	"net/http"
 	"os"
 	"os/signal"
-	"strconv"
+	"path/filepath"
 	"time"
 
 	"github.com/disgoorg/disgo"
@@ -20,23 +25,27 @@ import (
 	"github.com/disgoorg/disgo/rest"
 
 	"git.sunturtle.xyz/zephyr/horse/horse"
-	"git.sunturtle.xyz/zephyr/horse/horse/global"
 )
 
 func main() {
 	var (
+		// public site
+		addr    string
+		dataDir string
+		public  string
+		// discord
 		tokenFile string
-		// http api options
-		addr   string
-		route  string
-		pubkey string
-		// logging options
+		apiRoute  string
+		pubkey    string
+		// logging
 		level   slog.Level
 		textfmt string
 	)
+	flag.StringVar(&addr, "http", ":80", "`address` to bind HTTP server")
+	flag.StringVar(&dataDir, "data", "", "`dir`ectory containing exported json data")
+	flag.StringVar(&public, "public", "", "`dir`ectory containing the website to serve")
 	flag.StringVar(&tokenFile, "token", "", "`file` containing the Discord bot token")
-	flag.StringVar(&addr, "http", "", "`address` to bind HTTP API server")
-	flag.StringVar(&route, "route", "/interactions/callback", "`path` to serve HTTP API calls")
+	flag.StringVar(&apiRoute, "route", "/interactions/callback", "`path` to serve Discord HTTP API calls")
 	flag.StringVar(&pubkey, "key", "", "Discord public key")
 	flag.TextVar(&level, "log", slog.LevelInfo, "slog logging `level`")
 	flag.StringVar(&textfmt, "log-format", "text", "slog logging `format`, text or json")
@@ -54,6 +63,27 @@ func main() {
 	}
 	slog.SetDefault(slog.New(lh))
 
+	stat, err := os.Stat(public)
+	if err != nil {
+		slog.Error("public", slog.Any("err", err))
+		os.Exit(1)
+	}
+	if !stat.IsDir() {
+		slog.Error("public", slog.String("err", "not a directory"))
+		os.Exit(1)
+	}
+
+	skills, err := loadSkills(filepath.Join(dataDir, "skill.json"))
+	slog.Info("loaded skills", slog.Int("count", len(skills)))
+	groups, err2 := loadSkillGroups(filepath.Join(dataDir, "skill-group.json"))
+	slog.Info("loaded skill groups", slog.Int("count", len(groups)))
+	if err = errors.Join(err, err2); err != nil {
+		slog.Error("loading data", slog.Any("err", err))
+		os.Exit(1)
+	}
+	skillSrv := newSkillServer(skills, groups)
+	slog.Info("skill server ready")
+
 	token, err := os.ReadFile(tokenFile)
 	if err != nil {
 		slog.Error("reading token", slog.Any("err", err))
@@ -68,42 +98,55 @@ func main() {
 	r.Use(middleware.Go)
 	r.Use(logMiddleware)
 	r.Route("/skill", func(r handler.Router) {
-		r.SlashCommand("/", skillHandler)
-		r.Autocomplete("/", skillAutocomplete)
-		r.ButtonComponent("/{id}", skillButton)
+		r.SlashCommand("/", skillSrv.slash)
+		r.Autocomplete("/", skillSrv.autocomplete)
+		r.SelectMenuComponent("/swap", skillSrv.menu)
+		r.ButtonComponent("/swap/{id}", skillSrv.button)
 	})
-
-	opts := []bot.ConfigOpt{bot.WithDefaultGateway(), bot.WithEventListeners(r)}
-	if addr != "" {
-		if pubkey == "" {
-			slog.Error("Discord public key must be provided when using HTTP API")
-			os.Exit(1)
-		}
-		opts = append(opts, bot.WithHTTPServerConfigOpts(pubkey,
-			httpserver.WithAddress(addr),
-			httpserver.WithURL(route),
-		))
-	}
-
 	slog.Info("connect", slog.String("disgo", disgo.Version))
-	client, err := disgo.New(string(token), opts...)
+	client, err := disgo.New(string(token), bot.WithDefaultGateway(), bot.WithEventListeners(r))
 	if err != nil {
 		slog.Error("building bot", slog.Any("err", err))
 		os.Exit(1)
 	}
 
+	mux := http.NewServeMux()
+	mux.Handle("GET /", http.FileServerFS(os.DirFS(public)))
+	if pubkey != "" {
+		pk, err := hex.DecodeString(pubkey)
+		if err != nil {
+			slog.Error("pubkey", slog.Any("err", err))
+			os.Exit(1)
+		}
+		mux.Handle("POST "+apiRoute, httpserver.HandleInteraction(httpserver.DefaultVerifier{}, pk, slog.Default(), client.EventManager.HandleHTTPEvent))
+		slog.Info("Discord HTTP API enabled", slog.String("pubkey", pubkey))
+	}
+	l, err := net.Listen("tcp", addr)
+	if err != nil {
+		slog.Error("listen", slog.String("addr", addr), slog.Any("err", err))
+		os.Exit(1)
+	}
+	srv := http.Server{
+		Addr:         addr,
+		Handler:      mux,
+		ReadTimeout:  15 * time.Second,
+		WriteTimeout: 15 * time.Second,
+		BaseContext:  func(l net.Listener) context.Context { return ctx },
+	}
+	go func() {
+		slog.Info("HTTP", slog.Any("addr", l.Addr()))
+		err := srv.Serve(l)
+		if err == http.ErrServerClosed {
+			return
+		}
+		slog.Error("HTTP server closed", slog.Any("err", err))
+	}()
+
 	if err := handler.SyncCommands(client, commands, nil, rest.WithCtx(ctx)); err != nil {
 		slog.Error("syncing commands", slog.Any("err", err))
 		os.Exit(1)
 	}
 
-	if addr != "" {
-		slog.Info("start HTTP server", slog.String("address", addr), slog.String("route", route))
-		if err := client.OpenHTTPServer(); err != nil {
-			slog.Error("starting HTTP server", slog.Any("err", err))
-			stop()
-		}
-	}
 	slog.Info("start gateway")
 	if err := client.OpenGateway(ctx); err != nil {
 		slog.Error("starting gateway", slog.Any("err", err))
@@ -116,6 +159,10 @@ func main() {
 	ctx, stop = context.WithTimeout(context.Background(), 5*time.Second)
 	defer stop()
 	client.Close(ctx)
+	if err := srv.Shutdown(ctx); err != nil {
+		slog.Error("HTTP API shutdown", slog.Any("err", err))
+		os.Exit(1)
+	}
 }
 
 var commands = []discord.ApplicationCommandCreate{
@@ -129,55 +176,34 @@ var commands = []discord.ApplicationCommandCreate{
 				Required:     true,
 				Autocomplete: true,
 			},
+			discord.ApplicationCommandOptionBool{
+				Name:        "share",
+				Description: "Share the skill info",
+			},
 		},
 	},
 }
 
-func skillHandler(data discord.SlashCommandInteractionData, e *handler.CommandEvent) error {
-	q := data.String("query")
-	id, err := strconv.ParseInt(q, 10, 32)
-	if err == nil {
-		// note inverted condition; this is when we have an id
-		id = int64(global.AllSkills[horse.SkillID(id)].ID)
-	}
-	if id == 0 {
-		// Either we weren't given a number or the number doesn't match any skill ID.
-		v := global.SkillNameToID[q]
-		if v == 0 {
-			// No such skill.
-			m := discord.MessageCreate{
-				Content: "No such skill.",
-				Flags:   discord.MessageFlagEphemeral,
-			}
-			return e.CreateMessage(m)
-		}
-		id = int64(v)
-	}
-	// TODO(zeph): search conditions and effects, give a list
-	m := discord.MessageCreate{
-		Components: []discord.LayoutComponent{RenderSkill(horse.SkillID(id), global.AllSkills, global.SkillGroups)},
-		Flags:      discord.MessageFlagIsComponentsV2,
-	}
-	return e.CreateMessage(m)
-}
-
-func skillAutocomplete(e *handler.AutocompleteEvent) error {
-	q := e.Data.String("query")
-	opts := skillGlobalAuto().Find(nil, q)
-	return e.AutocompleteResult(opts[:min(len(opts), 25)])
-}
-
-func skillButton(data discord.ButtonInteractionData, e *handler.ComponentEvent) error {
-	id, err := strconv.ParseInt(e.Vars["id"], 10, 32)
+func loadSkills(file string) ([]horse.Skill, error) {
+	b, err := os.ReadFile(file)
 	if err != nil {
-		m := discord.MessageCreate{
-			Content: "That button produced an invalid skill ID. That's not supposed to happen.",
-			Flags:   discord.MessageFlagEphemeral,
-		}
-		return e.CreateMessage(m)
+		return nil, err
 	}
-	m := discord.MessageUpdate{
-		Components: &[]discord.LayoutComponent{RenderSkill(horse.SkillID(id), global.AllSkills, global.SkillGroups)},
+	var skills []horse.Skill
+	if err := json.Unmarshal(b, &skills); err != nil {
+		return nil, err
 	}
-	return e.UpdateMessage(m)
+	return skills, nil
+}
+
+func loadSkillGroups(file string) ([]horse.SkillGroup, error) {
+	b, err := os.ReadFile(file)
+	if err != nil {
+		return nil, err
+	}
+	var groups []horse.SkillGroup
+	if err := json.Unmarshal(b, &groups); err != nil {
+		return nil, err
+	}
+	return groups, nil
 }

cmd/horsebot/skill.go

@@ -2,67 +2,167 @@ package main
 
 import (
 	"fmt"
+	"log/slog"
+	"strconv"
 	"strings"
-	"sync"
 
 	"github.com/disgoorg/disgo/discord"
+	"github.com/disgoorg/disgo/handler"
 
 	"git.sunturtle.xyz/zephyr/horse/cmd/horsebot/autocomplete"
 	"git.sunturtle.xyz/zephyr/horse/horse"
-	"git.sunturtle.xyz/zephyr/horse/horse/global"
 )
 
-func RenderSkill(id horse.SkillID, all map[horse.SkillID]horse.Skill, groups map[int32][4]horse.SkillID) discord.ContainerComponent {
-	s, ok := all[id]
+type skillServer struct {
+	skills  map[horse.SkillID]horse.Skill
+	byName  map[string]horse.SkillID
+	groups  map[horse.SkillGroupID]horse.SkillGroup
+	autocom autocomplete.Set[discord.AutocompleteChoice]
+}
+
+func newSkillServer(skills []horse.Skill, groups []horse.SkillGroup) *skillServer {
+	s := skillServer{
+		skills: make(map[horse.SkillID]horse.Skill, len(skills)),
+		byName: make(map[string]horse.SkillID, len(skills)),
+		groups: make(map[horse.SkillGroupID]horse.SkillGroup, len(groups)),
+	}
+	for _, skill := range skills {
+		s.skills[skill.ID] = skill
+		s.byName[skill.Name] = skill.ID
+		switch {
+		case skill.UniqueOwner == "":
+			s.autocom.Add(skill.Name, discord.AutocompleteChoiceString{Name: skill.Name, Value: strconv.Itoa(int(skill.ID))})
+		case skill.Rarity >= 3:
+			s.autocom.Add(skill.Name, discord.AutocompleteChoiceString{Name: skill.Name, Value: skill.Name})
+			s.autocom.Add(skill.UniqueOwner, discord.AutocompleteChoiceString{Name: "Unique: " + skill.UniqueOwner, Value: strconv.Itoa(int(skill.ID))})
+		default:
+			s.autocom.Add(skill.Name, discord.AutocompleteChoiceString{Name: skill.Name + " (Inherited)", Value: strconv.Itoa(int(skill.ID))})
+			s.autocom.Add(skill.UniqueOwner, discord.AutocompleteChoiceString{Name: "Inherited unique: " + skill.UniqueOwner, Value: skill.Name})
+		}
+	}
+	for _, g := range groups {
+		s.groups[g.ID] = g
+	}
+	return &s
+}
+
+func (s *skillServer) slash(data discord.SlashCommandInteractionData, e *handler.CommandEvent) error {
+	q := data.String("query")
+	id, err := strconv.ParseInt(q, 10, 32)
+	if err == nil {
+		// note inverted condition; this is when we have an id
+		id = int64(s.skills[horse.SkillID(id)].ID)
+	}
+	if id == 0 {
+		// Either we weren't given a number or the number doesn't match any skill ID.
+		v := s.byName[q]
+		if v == 0 {
+			// No such skill.
+			m := discord.MessageCreate{
+				Content: "No such skill.",
+				Flags:   discord.MessageFlagEphemeral,
+			}
+			return e.CreateMessage(m)
+		}
+		id = int64(v)
+	}
+	m := discord.MessageCreate{
+		Components: []discord.LayoutComponent{s.render(horse.SkillID(id))},
+		Flags:      discord.MessageFlagIsComponentsV2,
+	}
+	if !data.Bool("share") {
+		m.Flags |= discord.MessageFlagEphemeral
+	}
+	return e.CreateMessage(m)
+}
+
+func (s *skillServer) autocomplete(e *handler.AutocompleteEvent) error {
+	q := e.Data.String("query")
+	opts := s.autocom.Find(nil, q)
+	return e.AutocompleteResult(opts[:min(len(opts), 25)])
+}
+
+func (s *skillServer) button(data discord.ButtonInteractionData, e *handler.ComponentEvent) error {
+	id, err := strconv.ParseInt(e.Vars["id"], 10, 32)
+	if err != nil {
+		m := discord.MessageCreate{
+			Content: "That button produced an invalid skill ID. That's not supposed to happen.",
+			Flags:   discord.MessageFlagEphemeral,
+		}
+		return e.CreateMessage(m)
+	}
+	m := discord.MessageUpdate{
+		Components: &[]discord.LayoutComponent{s.render(horse.SkillID(id))},
+	}
+	return e.UpdateMessage(m)
+}
+
+func (s *skillServer) menu(data discord.SelectMenuInteractionData, e *handler.ComponentEvent) error {
+	d, ok := data.(discord.StringSelectMenuInteractionData)
 	if !ok {
-		return discord.NewContainer(discord.NewTextDisplayf("invalid skill ID %v made it to RenderSkill", id))
+		return fmt.Errorf("wrong select menu type %T", data)
+	}
+	if len(d.Values) != 1 {
+		return fmt.Errorf("wrong number of values: %q", d.Values)
+	}
+	id, err := strconv.ParseInt(d.Values[0], 10, 32)
+	if err != nil {
+		return err
+	}
+	m := discord.MessageUpdate{
+		Components: &[]discord.LayoutComponent{s.render(horse.SkillID(id))},
+	}
+	return e.UpdateMessage(m)
+}
+
+func (s *skillServer) render(id horse.SkillID) discord.ContainerComponent {
+	skill, ok := s.skills[id]
+	if !ok {
+		slog.Error("invalid skill id", slog.Int("id", int(id)))
+		return discord.NewContainer(discord.NewTextDisplayf("invalid skill ID %v made it to render", id))
 	}
 
-	thumburl := fmt.Sprintf("https://gametora.com/images/umamusume/skill_icons/utx_ico_skill_%d.png", s.IconID)
-	top := "## " + s.Name
-	if s.UniqueOwner != "" {
-		top += "\n-# " + s.UniqueOwner
+	top := "### " + skill.Name
+	if skill.UniqueOwner != "" {
+		top += "\n-# " + skill.UniqueOwner
 	}
 	r := discord.NewContainer(
-		discord.NewSection(
-			discord.NewTextDisplay(top),
-			discord.NewTextDisplay(s.Description),
-		).WithAccessory(discord.NewThumbnail(thumburl)),
+		discord.NewTextDisplay(top),
+		discord.NewSmallSeparator(),
 	)
 	var skilltype string
 	switch {
-	case s.Rarity == 3, s.Rarity == 4, s.Rarity == 5:
+	case skill.Rarity == 3, skill.Rarity == 4, skill.Rarity == 5:
 		// unique of various star levels
 		r.AccentColor = 0xaca4d4
 		skilltype = "Unique Skill"
-	case s.UniqueOwner != "":
+	case skill.UniqueOwner != "":
 		r.AccentColor = 0xcccccc
 		skilltype = "Inherited Unique"
-	case s.Rarity == 2:
+	case skill.Rarity == 2:
 		// rare (gold)
 		r.AccentColor = 0xd7c25b
 		skilltype = "Rare Skill"
-	case s.GroupRate == -1:
+	case skill.GroupRate == -1:
 		// negative (purple) skill
 		r.AccentColor = 0x9151d4
 		skilltype = "Negative Skill"
-	case !s.WitCheck:
+	case !skill.WitCheck:
 		// should be passive (green)
 		r.AccentColor = 0x66ae1c
 		skilltype = "Passive Skill"
-	case isDebuff(s):
+	case isDebuff(skill):
 		// debuff (red)
 		r.AccentColor = 0xe34747
 		skilltype = "Debuff Skill"
-	case s.Rarity == 1:
+	case skill.Rarity == 1:
 		// common (white)
 		r.AccentColor = 0xcccccc
 		skilltype = "Common Skill"
 	}
-	r.Components = append(r.Components, discord.NewSmallSeparator())
 	text := make([]string, 0, 3)
 	abils := make([]string, 0, 3)
-	for _, act := range s.Activations {
+	for _, act := range skill.Activations {
 		text, abils = text[:0], abils[:0]
 		if act.Precondition != "" {
 			text = append(text, "Precondition: "+formatCondition(act.Precondition))
@@ -76,8 +176,10 @@ func RenderSkill(id horse.SkillID, all map[horse.SkillID]horse.Skill, groups map
 			t = "Instantaneous "
 		case act.Duration >= 500e4:
 			t = "Permanent "
-		default:
+		case act.DurScale == horse.DurationDirect:
 			t = "For " + act.Duration.String() + "s, "
+		default:
+			t = "For " + act.Duration.String() + "s " + act.DurScale.String() + ", "
 		}
 		for _, a := range act.Abilities {
 			abils = append(abils, a.String())
@@ -90,24 +192,40 @@ func RenderSkill(id horse.SkillID, all map[horse.SkillID]horse.Skill, groups map
 		r.Components = append(r.Components, discord.NewTextDisplay(strings.Join(text, "\n")))
 	}
 
-	l := discord.NewTextDisplayf("%s ・ SP cost %d ・ Grade value %d ・ [Conditions on GameTora](https://gametora.com/umamusume/skill-condition-viewer?skill=%d)", skilltype, s.SPCost, s.GradeValue, s.ID)
+	l := discord.NewTextDisplayf("%s ・ SP cost %d ・ Grade value %d ・ [Conditions on GameTora](https://gametora.com/umamusume/skill-condition-viewer?skill=%d)", skilltype, skill.SPCost, skill.GradeValue, skill.ID)
 	r.Components = append(r.Components, discord.NewSmallSeparator(), l)
 	rel := make([]horse.Skill, 0, 4)
-	for _, id := range groups[s.Group] {
+	group := s.groups[skill.Group]
+	for _, id := range [...]horse.SkillID{group.Skill1, group.Skill2, group.Skill3, group.SkillBad} {
 		if id != 0 {
-			rel = append(rel, all[id])
+			rel = append(rel, s.skills[id])
 		}
 	}
 	if len(rel) > 1 {
-		buttons := make([]discord.InteractiveComponent, 0, 4)
+		opts := make([]discord.StringSelectMenuOption, 0, 4)
 		for _, rs := range rel {
-			b := discord.NewSecondaryButton(rs.Name, fmt.Sprintf("/skill/%d", rs.ID))
-			if rs.ID == id {
-				b = b.AsDisabled()
+			name := rs.Name
+			emoji := "⚪"
+			switch rs.Rarity {
+			case 1:
+				if rs.UniqueOwner != "" {
+					name += " (Inherited)"
+				}
+			case 2:
+				emoji = "🟡"
+			case 3, 4, 5:
+				emoji = "🟣"
+			default:
+				emoji = "⁉️"
 			}
-			buttons = append(buttons, b)
+			b := discord.NewStringSelectMenuOption(name, strconv.Itoa(int(rs.ID))).WithEmoji(discord.NewComponentEmoji(emoji))
+			if rs.ID == skill.ID {
+				b = b.WithDefault(true)
+			}
+			opts = append(opts, b)
 		}
-		r.Components = append(r.Components, discord.NewActionRow(buttons...))
+		row := discord.NewActionRow(discord.NewStringSelectMenu("/skill/swap", "Related skills", opts...))
+		r.Components = append(r.Components, row)
 	}
 	return r
 }
@@ -130,19 +248,3 @@ func isDebuff(s horse.Skill) bool {
 	}
 	return false
 }
-
-var skillGlobalAuto = sync.OnceValue(func() *autocomplete.Set[discord.AutocompleteChoice] {
-	var set autocomplete.Set[discord.AutocompleteChoice]
-	for _, id := range global.OrderedSkills {
-		s := global.AllSkills[id]
-		set.Add(s.Name, discord.AutocompleteChoiceString{Name: s.Name, Value: s.Name})
-		if s.UniqueOwner != "" {
-			if s.Rarity >= 3 {
-				set.Add(s.UniqueOwner, discord.AutocompleteChoiceString{Name: "Unique: " + s.UniqueOwner, Value: s.Name})
-			} else {
-				set.Add(s.UniqueOwner, discord.AutocompleteChoiceString{Name: "Inherited unique: " + s.UniqueOwner, Value: s.Name})
-			}
-		}
-	}
-	return &set
-})

cmd/horsegen/generate.go

@@ -0,0 +1,418 @@
+package main
+
+import (
+	"bufio"
+	"cmp"
+	"context"
+	_ "embed"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"log/slog"
+	"maps"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"slices"
+
+	"golang.org/x/sync/errgroup"
+	"zombiezen.com/go/sqlite"
+	"zombiezen.com/go/sqlite/sqlitex"
+
+	"git.sunturtle.xyz/zephyr/horse/horse"
+)
+
+func main() {
+	var (
+		mdb    string
+		out    string
+		region string
+	)
+	flag.StringVar(&mdb, "mdb", os.ExpandEnv(`$USERPROFILE\AppData\LocalLow\Cygames\Umamusume\master\master.mdb`), "`path` to Umamusume master.mdb")
+	flag.StringVar(&out, "o", `.`, "`dir`ectory for output files")
+	flag.StringVar(&region, "region", "global", "region the database is for (global, jp)")
+	flag.Parse()
+
+	slog.Info("open", slog.String("mdb", mdb))
+	db, err := sqlitex.NewPool(mdb, sqlitex.PoolOptions{Flags: sqlite.OpenReadOnly})
+	if err != nil {
+		slog.Error("opening mdb", slog.String("mdb", mdb), slog.Any("err", err))
+		os.Exit(1)
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	go func() {
+		<-ctx.Done()
+		stop()
+	}()
+
+	loadgroup, ctx1 := errgroup.WithContext(ctx)
+	charas := load(ctx1, loadgroup, db, "characters", characterSQL, func(s *sqlite.Stmt) horse.Character {
+		return horse.Character{
+			ID:   horse.CharacterID(s.ColumnInt(0)),
+			Name: s.ColumnText(1),
+		}
+	})
+	aff := load(ctx1, loadgroup, db, "pair affinity", affinitySQL, func(s *sqlite.Stmt) horse.AffinityRelation {
+		return horse.AffinityRelation{
+			IDA:      s.ColumnInt(0),
+			IDB:      s.ColumnInt(1),
+			IDC:      s.ColumnInt(2),
+			Affinity: s.ColumnInt(3),
+		}
+	})
+	umas := load(ctx1, loadgroup, db, "umas", umaSQL, func(s *sqlite.Stmt) horse.Uma {
+		return horse.Uma{
+			ID:          horse.UmaID(s.ColumnInt(0)),
+			CharacterID: horse.CharacterID(s.ColumnInt(1)),
+			Name:        s.ColumnText(2),
+			Variant:     s.ColumnText(3),
+			Sprint:      horse.AptitudeLevel(s.ColumnInt(4)),
+			Mile:        horse.AptitudeLevel(s.ColumnInt(6)),
+			Medium:      horse.AptitudeLevel(s.ColumnInt(7)),
+			Long:        horse.AptitudeLevel(s.ColumnInt(8)),
+			Front:       horse.AptitudeLevel(s.ColumnInt(9)),
+			Pace:        horse.AptitudeLevel(s.ColumnInt(10)),
+			Late:        horse.AptitudeLevel(s.ColumnInt(11)),
+			End:         horse.AptitudeLevel(s.ColumnInt(12)),
+			Turf:        horse.AptitudeLevel(s.ColumnInt(13)),
+			Dirt:        horse.AptitudeLevel(s.ColumnInt(14)),
+			Unique:      horse.SkillID(s.ColumnInt(15)),
+			Skill1:      horse.SkillID(s.ColumnInt(16)),
+			Skill2:      horse.SkillID(s.ColumnInt(17)),
+			Skill3:      horse.SkillID(s.ColumnInt(18)),
+			SkillPL2:    horse.SkillID(s.ColumnInt(19)),
+			SkillPL3:    horse.SkillID(s.ColumnInt(20)),
+			SkillPL4:    horse.SkillID(s.ColumnInt(21)),
+			SkillPL5:    horse.SkillID(s.ColumnInt(22)),
+		}
+	})
+	sg := load(ctx1, loadgroup, db, "skill groups", skillGroupSQL, func(s *sqlite.Stmt) horse.SkillGroup {
+		return horse.SkillGroup{
+			ID:       horse.SkillGroupID(s.ColumnInt(0)),
+			Skill1:   horse.SkillID(s.ColumnInt(1)),
+			Skill2:   horse.SkillID(s.ColumnInt(2)),
+			Skill3:   horse.SkillID(s.ColumnInt(3)),
+			SkillBad: horse.SkillID(s.ColumnInt(4)),
+		}
+	})
+	skills := load(ctx1, loadgroup, db, "skills", skillSQL, func(s *sqlite.Stmt) horse.Skill {
+		return horse.Skill{
+			ID:          horse.SkillID(s.ColumnInt(0)),
+			Name:        s.ColumnText(1),
+			Description: s.ColumnText(2),
+			Group:       horse.SkillGroupID(s.ColumnInt32(3)),
+			Rarity:      int8(s.ColumnInt(5)),
+			GroupRate:   int8(s.ColumnInt(6)),
+			GradeValue:  s.ColumnInt32(7),
+			WitCheck:    s.ColumnBool(8),
+			Activations: trimActivations([]horse.Activation{
+				{
+					Precondition: s.ColumnText(9),
+					Condition:    s.ColumnText(10),
+					Duration:     horse.TenThousandths(s.ColumnInt(11)),
+					DurScale:     horse.DurScale(s.ColumnInt(12)),
+					Cooldown:     horse.TenThousandths(s.ColumnInt(13)),
+					Abilities: trimAbilities([]horse.Ability{
+						{
+							Type:        horse.AbilityType(s.ColumnInt(14)),
+							ValueUsage:  horse.AbilityValueUsage(s.ColumnInt(15)),
+							Value:       horse.TenThousandths(s.ColumnInt(16)),
+							Target:      horse.AbilityTarget(s.ColumnInt(17)),
+							TargetValue: s.ColumnInt32(18),
+						},
+						{
+							Type:        horse.AbilityType(s.ColumnInt(19)),
+							ValueUsage:  horse.AbilityValueUsage(s.ColumnInt(20)),
+							Value:       horse.TenThousandths(s.ColumnInt(21)),
+							Target:      horse.AbilityTarget(s.ColumnInt(22)),
+							TargetValue: s.ColumnInt32(23),
+						},
+						{
+							Type:        horse.AbilityType(s.ColumnInt(24)),
+							ValueUsage:  horse.AbilityValueUsage(s.ColumnInt(25)),
+							Value:       horse.TenThousandths(s.ColumnInt(26)),
+							Target:      horse.AbilityTarget(s.ColumnInt(27)),
+							TargetValue: s.ColumnInt32(28),
+						},
+					}),
+				},
+				{
+					Precondition: s.ColumnText(29),
+					Condition:    s.ColumnText(30),
+					Duration:     horse.TenThousandths(s.ColumnInt(31)),
+					DurScale:     horse.DurScale(s.ColumnInt(32)),
+					Cooldown:     horse.TenThousandths(s.ColumnInt(33)),
+					Abilities: trimAbilities([]horse.Ability{
+						{
+							Type:        horse.AbilityType(s.ColumnInt(34)),
+							ValueUsage:  horse.AbilityValueUsage(s.ColumnInt(35)),
+							Value:       horse.TenThousandths(s.ColumnInt(36)),
+							Target:      horse.AbilityTarget(s.ColumnInt(37)),
+							TargetValue: s.ColumnInt32(38),
+						},
+						{
+							Type:        horse.AbilityType(s.ColumnInt(39)),
+							ValueUsage:  horse.AbilityValueUsage(s.ColumnInt(40)),
+							Value:       horse.TenThousandths(s.ColumnInt(41)),
+							Target:      horse.AbilityTarget(s.ColumnInt(42)),
+							TargetValue: s.ColumnInt32(43),
+						},
+						{
+							Type:        horse.AbilityType(s.ColumnInt(44)),
+							ValueUsage:  horse.AbilityValueUsage(s.ColumnInt(45)),
+							Value:       horse.TenThousandths(s.ColumnInt(46)),
+							Target:      horse.AbilityTarget(s.ColumnInt(47)),
+							TargetValue: s.ColumnInt32(48),
+						},
+					}),
+				},
+			}),
+			UniqueOwner: s.ColumnText(52), // TODO(zeph): should be id, not name
+			SPCost:      s.ColumnInt(49),
+			IconID:      s.ColumnInt(53),
+		}
+	})
+	races := load(ctx1, loadgroup, db, "races", raceSQL, func(s *sqlite.Stmt) horse.Race {
+		return horse.Race{
+			ID:   horse.RaceID(s.ColumnInt(0)),
+			Name: s.ColumnText(1),
+			// TODO(zeph): grade
+			Thumbnail: s.ColumnInt(3),
+			Primary:   horse.RaceID(s.ColumnInt(4)),
+		}
+	})
+	saddles := load(ctx1, loadgroup, db, "saddles", saddleSQL, func(s *sqlite.Stmt) horse.Saddle {
+		return horse.Saddle{
+			ID:   horse.SaddleID(s.ColumnInt(0)),
+			Name: s.ColumnText(1),
+			Races: trimZeros(
+				horse.RaceID(s.ColumnInt(2)),
+				horse.RaceID(s.ColumnInt(3)),
+				horse.RaceID(s.ColumnInt(4)),
+			),
+			Type:    horse.SaddleType(s.ColumnInt(5)),
+			Primary: horse.SaddleID(s.ColumnInt(6)),
+		}
+	})
+	scenarios := load(ctx1, loadgroup, db, "scenarios", scenarioSQL, func(s *sqlite.Stmt) horse.Scenario {
+		return horse.Scenario{
+			ID:    horse.ScenarioID(s.ColumnInt(0)),
+			Name:  s.ColumnText(1),
+			Title: s.ColumnText(2),
+		}
+	})
+	sparks := load(ctx1, loadgroup, db, "sparks", sparkSQL, func(s *sqlite.Stmt) horse.Spark {
+		return horse.Spark{
+			ID:          horse.SparkID(s.ColumnInt(0)),
+			Name:        s.ColumnText(1),
+			Description: s.ColumnText(2),
+			Group:       horse.SparkGroupID(s.ColumnInt(3)),
+			Rarity:      horse.SparkRarity(s.ColumnInt(4)),
+			Type:        horse.SparkType(s.ColumnInt(5)),
+			// Effects filled in later.
+		}
+	})
+	sparkeffs := load(ctx1, loadgroup, db, "spark effects", sparkEffectSQL, func(s *sqlite.Stmt) SparkEffImm {
+		return SparkEffImm{
+			Group:  horse.SparkGroupID(s.ColumnInt(0)),
+			Effect: s.ColumnInt(1),
+			Target: horse.SparkTarget(s.ColumnInt(2)),
+			Value1: s.ColumnInt32(3),
+			Value2: s.ColumnInt32(4),
+		}
+	})
+	convos := load(ctx1, loadgroup, db, "lobby conversations", conversationSQL, func(s *sqlite.Stmt) horse.Conversation {
+		return horse.Conversation{
+			CharacterID:   horse.CharacterID(s.ColumnInt(0)),
+			Number:        s.ColumnInt(1),
+			Location:      horse.LobbyConversationLocationID(s.ColumnInt(2)),
+			LocationName:  horse.LobbyConversationLocationID(s.ColumnInt(2)).String(),
+			Chara1:        horse.CharacterID(s.ColumnInt(3)),
+			Chara2:        horse.CharacterID(s.ColumnInt(4)),
+			Chara3:        horse.CharacterID(s.ColumnInt(5)),
+			ConditionType: s.ColumnInt(6),
+		}
+	})
+
+	if err := os.MkdirAll(filepath.Join(out, region), 0775); err != nil {
+		slog.Error("create output dir", slog.Any("err", err))
+		os.Exit(1)
+	}
+
+	writegroup, ctx2 := errgroup.WithContext(ctx)
+	writegroup.Go(func() error { return write(ctx2, out, region, "character.json", charas) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "affinity.json", aff) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "uma.json", umas) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "skill-group.json", sg) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "skill.json", skills) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "race.json", races) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "saddle.json", saddles) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "scenario.json", scenarios) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "spark.json", mergesparks(sparks, sparkeffs)) })
+	writegroup.Go(func() error { return write(ctx2, out, region, "conversation.json", convos) })
+	if err := writegroup.Wait(); err != nil {
+		slog.ErrorContext(ctx, "write", slog.Any("err", err))
+		os.Exit(1)
+	}
+
+	slog.InfoContext(ctx, "done")
+}
+
+var (
+	//go:embed sql/character.sql
+	characterSQL string
+	//go:embed sql/affinity.sql
+	affinitySQL string
+	//go:embed sql/uma.sql
+	umaSQL string
+	//go:embed sql/skill-group.sql
+	skillGroupSQL string
+	//go:embed sql/skill.sql
+	skillSQL string
+	//go:embed sql/race.sql
+	raceSQL string
+	//go:embed sql/saddle.sql
+	saddleSQL string
+	//go:embed sql/scenario.sql
+	scenarioSQL string
+	//go:embed sql/spark.sql
+	sparkSQL string
+	//go:embed sql/spark-effect.sql
+	sparkEffectSQL string
+	//go:embed sql/conversation.sql
+	conversationSQL string
+)
+
+func load[T any](ctx context.Context, group *errgroup.Group, db *sqlitex.Pool, kind, sql string, row func(*sqlite.Stmt) T) func() ([]T, error) {
+	slog.InfoContext(ctx, "load", slog.String("kind", kind))
+	var r []T
+	group.Go(func() error {
+		conn, err := db.Take(ctx)
+		defer db.Put(conn)
+		if err != nil {
+			return fmt.Errorf("couldn't get connection for %s: %w", kind, err)
+		}
+		stmt, _, err := conn.PrepareTransient(sql)
+		if err != nil {
+			return fmt.Errorf("couldn't prepare statement for %s: %w", kind, err)
+		}
+
+		for {
+			ok, err := stmt.Step()
+			if err != nil {
+				return fmt.Errorf("error stepping %s: %w", kind, err)
+			}
+			if !ok {
+				break
+			}
+			r = append(r, row(stmt))
+		}
+		return nil
+	})
+	return func() ([]T, error) {
+		err := group.Wait()
+		if err == context.Canceled {
+			// After the first wait, all future ones return context.Canceled.
+			// We want to be able to wait any number of times, so hide it.
+			err = nil
+		}
+		return r, err
+	}
+}
+
+func write[T any](ctx context.Context, out, region, name string, v func() (T, error)) error {
+	p := filepath.Join(out, region, name)
+	r, err := v()
+	if err != nil {
+		return err
+	}
+	slog.InfoContext(ctx, "write", slog.String("path", p))
+	f, err := os.Create(p)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	w := bufio.NewWriter(f)
+	enc := json.NewEncoder(w)
+	enc.SetEscapeHTML(false)
+	enc.SetIndent("", "\t")
+	err = enc.Encode(r)
+	err = errors.Join(err, w.Flush())
+	slog.InfoContext(ctx, "marshaled", slog.String("path", p))
+	return err
+}
+
+func mergesparks(sparks func() ([]horse.Spark, error), effs func() ([]SparkEffImm, error)) func() ([]horse.Spark, error) {
+	return func() ([]horse.Spark, error) {
+		sp, err := sparks()
+		if err != nil {
+			return nil, err
+		}
+		ef, err := effs()
+		if err != nil {
+			return nil, err
+		}
+		// Spark effects are sorted by group ID, but groups apply to multiple
+		// sparks, and we don't rely on sparks and groups being in the same order.
+		// It is possible to merge in linear time, but not worth the effort:
+		// n log n is fine since this is an AOT step.
+		for i := range sp {
+			k, ok := slices.BinarySearchFunc(ef, sp[i].Group, func(e SparkEffImm, v horse.SparkGroupID) int { return cmp.Compare(e.Group, v) })
+			if !ok {
+				panic(fmt.Errorf("mergesparks: no spark group for %+v", &sp[i]))
+			}
+			// Back up to the first effect in the group.
+			for k > 0 && ef[k-1].Group == sp[i].Group {
+				k--
+			}
+			// Map effect IDs to the lists of their effects.
+			m := make(map[int][]horse.SparkEffect)
+			for _, e := range ef[k:] {
+				if e.Group != sp[i].Group {
+					// Done with this group.
+					break
+				}
+				m[e.Effect] = append(m[e.Effect], horse.SparkEffect{Target: e.Target, Value1: e.Value1, Value2: e.Value2})
+			}
+			// Now get effects in order.
+			keys := slices.Sorted(maps.Keys(m))
+			sp[i].Effects = make([][]horse.SparkEffect, 0, len(keys))
+			for _, key := range keys {
+				sp[i].Effects = append(sp[i].Effects, m[key])
+			}
+		}
+		return sp, nil
+	}
+}
+
+type SparkEffImm struct {
+	Group  horse.SparkGroupID
+	Effect int
+	Target horse.SparkTarget
+	Value1 int32
+	Value2 int32
+}
+
+func trimAbilities(s []horse.Ability) []horse.Ability {
+	for len(s) > 0 && s[len(s)-1].Type == 0 {
+		s = s[:len(s)-1]
+	}
+	return s
+}
+
+func trimActivations(s []horse.Activation) []horse.Activation {
+	for len(s) > 0 && s[len(s)-1].Condition == "" {
+		s = s[:len(s)-1]
+	}
+	return s
+}
+
+func trimZeros[T comparable](s ...T) []T {
+	var zero T
+	for len(s) > 0 && s[len(s)-1] == zero {
+		s = s[:len(s)-1]
+	}
+	return s
+}

cmd/horsegen/sql/affinity.sql

@@ -0,0 +1,60 @@
+WITH pairs AS (
+	SELECT
+		a.id AS id_a,
+		b.id AS id_b
+	FROM chara_data a
+		JOIN chara_data b ON a.id < b.id
+	-- Exclude characters who have no succession relations defined.
+	WHERE a.id IN (SELECT chara_id FROM succession_relation_member)
+		AND b.id IN (SELECT chara_id FROM succession_relation_member)
+), trios AS (
+	SELECT
+		a.id AS id_a,
+		b.id AS id_b,
+		c.id AS id_c
+	FROM chara_data a
+		JOIN chara_data b ON a.id < b.id
+		JOIN chara_data c ON a.id < c.id AND b.id < c.id
+	-- Exclude characters who have no succession relations defined.
+	WHERE a.id IN (SELECT chara_id FROM succession_relation_member)
+		AND b.id IN (SELECT chara_id FROM succession_relation_member)
+		AND c.id IN (SELECT chara_id FROM succession_relation_member)
+), pair_relations AS (
+	SELECT
+		ra.relation_type,
+		ra.chara_id AS id_a,
+		rb.chara_id AS id_b
+	FROM succession_relation_member ra
+		JOIN succession_relation_member rb ON ra.relation_type = rb.relation_type
+), trio_relations AS (
+	SELECT
+		ra.relation_type,
+		ra.chara_id AS id_a,
+		rb.chara_id AS id_b,
+		rc.chara_id AS id_c
+	FROM succession_relation_member ra
+		JOIN succession_relation_member rb ON ra.relation_type = rb.relation_type
+		JOIN succession_relation_member rc ON ra.relation_type = rc.relation_type
+), affinity AS (
+	SELECT
+		pairs.*,
+		0 AS id_c,
+		SUM(IFNULL(relation_point, 0)) AS base_affinity
+	FROM pairs
+		LEFT JOIN pair_relations rp ON pairs.id_a = rp.id_a AND pairs.id_b = rp.id_b
+		LEFT JOIN succession_relation sr ON rp.relation_type = sr.relation_type
+	GROUP BY pairs.id_a, pairs.id_b
+
+	UNION ALL
+
+	SELECT
+		trios.*,
+		SUM(IFNULL(relation_point, 0)) AS base_affinity
+	FROM trios
+		LEFT JOIN trio_relations rt ON trios.id_a = rt.id_a AND trios.id_b = rt.id_b AND trios.id_c = rt.id_c
+		LEFT JOIN succession_relation sr ON rt.relation_type = sr.relation_type
+	GROUP BY trios.id_a, trios.id_b, trios.id_c
+)
+SELECT * FROM affinity
+WHERE base_affinity != 0
+ORDER BY id_a, id_b, id_c

cmd/horsegen/sql/conversation.sql

@@ -0,0 +1,10 @@
+SELECT
+	gallery_chara_id,
+    disp_order,
+	pos_id,
+	chara_id_1,
+	chara_id_2,
+	chara_id_3,
+    condition_type
+FROM home_story_trigger
+ORDER BY gallery_chara_id, disp_order

cmd/horsegen/sql/skill-group.sql

@@ -0,0 +1,17 @@
+WITH skill_groups AS (
+	SELECT DISTINCT group_id FROM skill_data
+)
+SELECT
+	g.group_id,
+	COALESCE(inh_from.id, s1.id, 0) AS skill1,
+	COALESCE(inh_to.id, s2.id, 0) AS skill2,
+	IFNULL(s3.id, 0) AS skill3,
+	IFNULL(m1.id, 0) AS skill_bad
+FROM skill_groups g
+	LEFT JOIN skill_data s1 ON g.group_id = s1.group_id AND s1.group_rate = 1
+	LEFT JOIN skill_data s2 ON g.group_id = s2.group_id AND s2.group_rate = 2
+	LEFT JOIN skill_data s3 ON g.group_id = s3.group_id AND s3.group_rate = 3
+	LEFT JOIN skill_data m1 ON g.group_id = m1.group_id AND m1.group_rate = -1
+	LEFT JOIN skill_data inh_to ON s1.id = inh_to.unique_skill_id_1
+	LEFT JOIN skill_data inh_from ON s2.unique_skill_id_1 = inh_from.id
+ORDER BY g.group_id

cmd/horsegen/sql/skill.sql

@@ -45,6 +45,7 @@ SELECT
 	d.precondition_1,
 	d.condition_1,
 	d.float_ability_time_1,
+	d.ability_time_usage_1,
 	d.float_cooldown_time_1,
 	d.ability_type_1_1,
 	d.ability_value_usage_1_1,
@@ -64,6 +65,7 @@ SELECT
 	d.precondition_2,
 	d.condition_2,
 	d.float_ability_time_2,
+	d.ability_time_usage_2,
 	d.float_cooldown_time_2,
 	d.ability_type_2_1,
 	d.ability_value_usage_2_1,

cmd/horsegen/sql/spark-effect.sql

@@ -6,4 +6,4 @@ SELECT
 	value_2
 FROM succession_factor_effect
 WHERE factor_group_id NOT IN (40001) -- exclude Carnival Bonus
-ORDER BY factor_group_id, effect_id, target_type
+ORDER BY factor_group_id, effect_id, id

cmd/horsegen/sql/uma.sql

@@ -0,0 +1,59 @@
+WITH uma_name AS (
+	SELECT "index" AS id, "text" AS name
+	FROM text_data
+	WHERE category = 4
+), uma_variant AS (
+	SELECT "index" AS id, "text" AS variant
+	FROM text_data
+	WHERE category = 5
+), chara_name AS (
+	SELECT "index" AS id, "text" AS name
+	FROM text_data
+	WHERE category = 6
+), skills AS (
+	SELECT
+		uma.id,
+		s.skill_id,
+		s.need_rank,
+		ROW_NUMBER() OVER (PARTITION BY s.available_skill_set_id, s.need_rank) AS idx
+	FROM card_data uma
+		LEFT JOIN available_skill_set s ON uma.available_skill_set_id = s.available_skill_set_id
+)
+SELECT
+	uma.card_id,
+	card_data.chara_id,
+	n.name,
+	v.variant,
+	c.name AS chara_name,
+	uma.proper_distance_short,
+	uma.proper_distance_mile,
+	uma.proper_distance_middle,
+	uma.proper_distance_long,
+	uma.proper_running_style_nige,
+	uma.proper_running_style_senko,
+	uma.proper_running_style_sashi,
+	uma.proper_running_style_oikomi,
+	uma.proper_ground_turf,
+	uma.proper_ground_dirt,
+	su.skill_id1 AS unique_skill,
+	s1.skill_id AS skill1,
+	s2.skill_id AS skill2,
+	s3.skill_id AS skill3,
+	sp2.skill_id AS skill_pl2,
+	sp3.skill_id AS skill_pl3,
+	sp4.skill_id AS skill_pl4,
+	sp5.skill_id AS skill_pl5
+FROM card_data
+	JOIN card_rarity_data uma ON card_data.id = uma.card_id
+	JOIN chara_name c ON card_data.chara_id = c.id
+	JOIN skill_set su ON uma.skill_set = su.id
+	JOIN skills s1 ON uma.card_id = s1.id AND s1.need_rank = 0 AND s1.idx = 1
+	JOIN skills s2 ON uma.card_id = s2.id AND s2.need_rank = 0 AND s2.idx = 2
+	JOIN skills s3 ON uma.card_id = s3.id AND s3.need_rank = 0 AND s3.idx = 3
+	JOIN skills sp2 ON uma.card_id = sp2.id AND sp2.need_rank = 2
+	JOIN skills sp3 ON uma.card_id = sp3.id AND sp3.need_rank = 3
+	JOIN skills sp4 ON uma.card_id = sp4.id AND sp4.need_rank = 4
+	JOIN skills sp5 ON uma.card_id = sp5.id AND sp5.need_rank = 5
+	LEFT JOIN uma_name n ON uma.card_id = n.id
+	LEFT JOIN uma_variant v ON uma.card_id = v.id
+WHERE uma.rarity = 5

doc/README.md

@@ -6,13 +6,14 @@ This file is my notes from exploring the database.
 
 # text_data categories
 
-- 6 is character names, 4 is [variant] character name, 5 is [variant], 14 is variant
+- 6 is character names, 4 is [variant] character name, 5 is [variant], 14 is clothing names
 - 47 is skill names, 48 is skill descriptions
 - 75 is support card names incl. variant, 76 is support card variant, 77 is support card character
 - 147 is spark names, 172 is spark descriptions
 - 33 is race names by race id, 28 is race names by race instance id, 31 is race courses, 111 is saddle names
 - 65 is player titles, 66 is title descriptions - ties with honor_data?
 - 119 is scenario full titles (e.g. The Beginning: URA Finale), 120 is scenario descriptions, 237 is scenario names (e.g. URA Finale)
+- 130 is epithet names, 131 is epithet descriptions
 
 # succession factor (sparks)
 
@@ -64,9 +65,6 @@ effect_id distinguishes possibilities; factors with multiple effects (race and s
 effect_group_id determines the pmf, but no tables have non-empty joins with the same column name, so the distribution values are mystery.
 even searching for 51 and 52 (effect group ids for 1\* and 2\* race and scenario sparks) on consecutive lines gives nothing.
 
-sf.grade = 1 unless it is a unique (green) spark, then sf.grade = 2.
-=> sf.grade = 2 iff sf.factor_type = 3
-
 getting all interesting spark data, fully expanded with all effects:
 ```sql
 WITH spark AS (
@@ -195,12 +193,41 @@ target types:
 - 22 specific character, target value is character id
 - 23 other who triggered the skill
 
-TODO target types only in jp: 2, 7, 11, 22, 23
-
 ability_value_usage can be 1 for plain or 2-6 for aoharu stat skill stat scaling
 
 seems to be activate_lot = 1 means wit check, 0 means guaranteed
 
+tag_id is a slash-separated list of numeric IDs that roughly describe all effects relevant to the skill.
+- 101..104 style front, pace, late, end
+- 201..204 distance sprint, mile, medium, long
+- 301..303 timing early, mid, late race
+- 401 affects speed stat or target speed
+- 402 affects stamina stat or hp
+- 403 affects power stat or acceleration
+- 404 affects guts stat
+- 405 affects wit stat or vision
+- 406 is a debuff of any type, or is a main story self-debuff (creeping anxiety, blatant fear), or is Behold Thine Emperor's Divine Might (both own unique and inherited versions are tagged only 406??)
+- 407 modifies gate delay
+- 501..502 turf/dirt
+- 801..812 scenario skill
+
+600 series applies to skills available in global but are only used in jp.
+- 601 ground condition passive
+- 602 weather passive
+- 603 season passive
+- 604 race track passive
+- 605 time of day passive
+- 606 exchange race passive (kawasaki, funabashi, morioka, ooi)
+- 607 distance passive (non/standard)
+- 608 track direction or corner count passive
+- 609 gate position passive
+- 610 ground type passive
+- 611 popularity passive
+- 612 running style passive
+- 613 passive depending on other horses' styles or skills
+- 614 base stat threshold passive
+- 615 mood passive
+
 # races
 
 - group 1, grade: g1 100, g2 200, g3 300, op 400, pre-op 700
@@ -232,6 +259,72 @@ so, it doesn't seem like there's a particular flag that identifies maiden races,
 - card_talent_upgrade has costs to increase potential level, but it doesn't seem to have skill sets
 - card_talent_hint_upgrade has costs to raise hint levels, but it's actually universal, only six rows
 - single_mode_route_race is career goals (not only races)
+- available_skill_set has starting skills including those unlocked by potential level given under need_rank (0 for pl1, 2 for pl2)
+
+# lobby conversations!!!
+
+table is home_story_trigger.
+
+pos_id values:
+- 110 right side, toward the front
+- 120 same, but two characters
+- 130 same, but three characters
+- 210 left side table
+- 220
+- 310 center back seat
+- 410 center posters
+- 420
+- 430
+- 510 left school map
+- 520
+- 530
+
+num is how many characters are involved, but also can just check chara_id_{1,2,3} for nonzero.
+
+unsure what condition_type is.
+values of 2 and 3 always have two or three characters, and values of 4 (jp only) always have three, but 0 and 1 can have any number.
+there's no requirement for stories like having a horse at all, much less an affinity level.
+
+gallery_chara_id is the character whose conversation it is; chara_id_{1,2,3} are the characters involved.
+gallery_chara_id is always one of the three, but it can be any one of the three.
+disp_order then is the conversation number within their gallery.
+
+getting all conversation data:
+```sql
+WITH chara_name AS (
+    SELECT "index" AS id, "text" AS name
+    FROM text_data
+    WHERE category = 6
+), convo_loc_names AS (
+    SELECT 110 AS pos_id, 'right side front' AS name UNION ALL
+    SELECT 120 AS pos_id, 'right side front' AS name UNION ALL
+    SELECT 130 AS pos_id, 'right side front' AS name UNION ALL
+    SELECT 210 AS pos_id, 'left side table' AS name UNION ALL
+    SELECT 220 AS pos_id, 'left side table' AS name UNION ALL
+    SELECT 310 AS pos_id, 'center back seat' AS name UNION ALL
+    SELECT 410 AS pos_id, 'center posters' AS name UNION ALL
+    SELECT 420 AS pos_id, 'center posters' AS name UNION ALL
+    SELECT 430 AS pos_id, 'center posters' AS name UNION ALL
+    SELECT 510 AS pos_id, 'left side school map' AS name UNION ALL
+    SELECT 520 AS pos_id, 'left side school map' AS name UNION ALL
+    SELECT 530 AS pos_id, 'left side school map' AS name
+)
+SELECT
+    n.name,
+    s.disp_order,
+    l.name,
+    c1.name,
+    c2.name,
+    c3.name,
+    s.condition_type
+FROM home_story_trigger s
+    LEFT JOIN chara_name n ON s.gallery_chara_id = n.id
+    LEFT JOIN chara_name c1 ON s.chara_id_1 = c1.id
+    LEFT JOIN chara_name c2 ON s.chara_id_2 = c2.id
+    LEFT JOIN chara_name c3 ON s.chara_id_3 = c3.id
+    LEFT JOIN convo_loc_names l ON s.pos_id = l.pos_id
+ORDER BY s.gallery_chara_id, s.disp_order
+```
 
 # update diffs
 

global/character.json

@@ -0,0 +1,226 @@
+[
+	{
+		"chara_id": 1001,
+		"name": "Special Week"
+	},
+	{
+		"chara_id": 1002,
+		"name": "Silence Suzuka"
+	},
+	{
+		"chara_id": 1003,
+		"name": "Tokai Teio"
+	},
+	{
+		"chara_id": 1004,
+		"name": "Maruzensky"
+	},
+	{
+		"chara_id": 1005,
+		"name": "Fuji Kiseki"
+	},
+	{
+		"chara_id": 1006,
+		"name": "Oguri Cap"
+	},
+	{
+		"chara_id": 1007,
+		"name": "Gold Ship"
+	},
+	{
+		"chara_id": 1008,
+		"name": "Vodka"
+	},
+	{
+		"chara_id": 1009,
+		"name": "Daiwa Scarlet"
+	},
+	{
+		"chara_id": 1010,
+		"name": "Taiki Shuttle"
+	},
+	{
+		"chara_id": 1011,
+		"name": "Grass Wonder"
+	},
+	{
+		"chara_id": 1012,
+		"name": "Hishi Amazon"
+	},
+	{
+		"chara_id": 1013,
+		"name": "Mejiro McQueen"
+	},
+	{
+		"chara_id": 1014,
+		"name": "El Condor Pasa"
+	},
+	{
+		"chara_id": 1015,
+		"name": "T.M. Opera O"
+	},
+	{
+		"chara_id": 1016,
+		"name": "Narita Brian"
+	},
+	{
+		"chara_id": 1017,
+		"name": "Symboli Rudolf"
+	},
+	{
+		"chara_id": 1018,
+		"name": "Air Groove"
+	},
+	{
+		"chara_id": 1019,
+		"name": "Agnes Digital"
+	},
+	{
+		"chara_id": 1020,
+		"name": "Seiun Sky"
+	},
+	{
+		"chara_id": 1021,
+		"name": "Tamamo Cross"
+	},
+	{
+		"chara_id": 1022,
+		"name": "Fine Motion"
+	},
+	{
+		"chara_id": 1023,
+		"name": "Biwa Hayahide"
+	},
+	{
+		"chara_id": 1024,
+		"name": "Mayano Top Gun"
+	},
+	{
+		"chara_id": 1025,
+		"name": "Manhattan Cafe"
+	},
+	{
+		"chara_id": 1026,
+		"name": "Mihono Bourbon"
+	},
+	{
+		"chara_id": 1027,
+		"name": "Mejiro Ryan"
+	},
+	{
+		"chara_id": 1028,
+		"name": "Hishi Akebono"
+	},
+	{
+		"chara_id": 1030,
+		"name": "Rice Shower"
+	},
+	{
+		"chara_id": 1032,
+		"name": "Agnes Tachyon"
+	},
+	{
+		"chara_id": 1033,
+		"name": "Admire Vega"
+	},
+	{
+		"chara_id": 1034,
+		"name": "Inari One"
+	},
+	{
+		"chara_id": 1035,
+		"name": "Winning Ticket"
+	},
+	{
+		"chara_id": 1037,
+		"name": "Eishin Flash"
+	},
+	{
+		"chara_id": 1038,
+		"name": "Curren Chan"
+	},
+	{
+		"chara_id": 1039,
+		"name": "Kawakami Princess"
+	},
+	{
+		"chara_id": 1040,
+		"name": "Gold City"
+	},
+	{
+		"chara_id": 1041,
+		"name": "Sakura Bakushin O"
+	},
+	{
+		"chara_id": 1044,
+		"name": "Sweep Tosho"
+	},
+	{
+		"chara_id": 1045,
+		"name": "Super Creek"
+	},
+	{
+		"chara_id": 1046,
+		"name": "Smart Falcon"
+	},
+	{
+		"chara_id": 1048,
+		"name": "Tosen Jordan"
+	},
+	{
+		"chara_id": 1050,
+		"name": "Narita Taishin"
+	},
+	{
+		"chara_id": 1051,
+		"name": "Nishino Flower"
+	},
+	{
+		"chara_id": 1052,
+		"name": "Haru Urara"
+	},
+	{
+		"chara_id": 1056,
+		"name": "Matikanefukukitaru"
+	},
+	{
+		"chara_id": 1058,
+		"name": "Meisho Doto"
+	},
+	{
+		"chara_id": 1059,
+		"name": "Mejiro Dober"
+	},
+	{
+		"chara_id": 1060,
+		"name": "Nice Nature"
+	},
+	{
+		"chara_id": 1061,
+		"name": "King Halo"
+	},
+	{
+		"chara_id": 1062,
+		"name": "Matikanetannhauser"
+	},
+	{
+		"chara_id": 1067,
+		"name": "Satono Diamond"
+	},
+	{
+		"chara_id": 1068,
+		"name": "Kitasan Black"
+	},
+	{
+		"chara_id": 1069,
+		"name": "Sakura Chiyono O"
+	},
+	{
+		"chara_id": 1071,
+		"name": "Mejiro Ardan"
+	},
+	{
+		"chara_id": 1074,
+		"name": "Mejiro Bright"
+	}
+]

global/scenario.json

@@ -0,0 +1,17 @@
+[
+	{
+		"scenario_id": 1,
+		"name": "URA Finale",
+		"title": "The Beginning: URA Finale"
+	},
+	{
+		"scenario_id": 2,
+		"name": "Unity Cup",
+		"title": "Unity Cup: Shine On, Team Spirit!"
+	},
+	{
+		"scenario_id": 4,
+		"name": "TS Climax",
+		"title": "Trackblazer: Start of the Climax"
+	}
+]

go-generate.go

@@ -1,13 +0,0 @@
-package main
-
-import "os"
-
-//go:generate go run ./horsegen
-//go:generate go generate ./horse/...
-//go:generate go fmt ./...
-//go:generate go test ./...
-
-func main() {
-	os.Stderr.WriteString("go generate, not go run\n")
-	os.Exit(2)
-}

go.mod

@@ -5,7 +5,7 @@ go 1.25.5
 require (
 	github.com/disgoorg/disgo v0.19.0-rc.15
 	github.com/junegunn/fzf v0.67.0
-	golang.org/x/sync v0.14.0
+	golang.org/x/sync v0.20.0
 	zombiezen.com/go/sqlite v1.4.2
 )
 

go.sum

@@ -40,8 +40,8 @@ golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5Z
 golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8=
 golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
 golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
-golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
-golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
 golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=

horse/aptitudelevel_string.go

@@ -0,0 +1,31 @@
+// Code generated by "stringer -type AptitudeLevel -trimprefix AptitudeLv"; DO NOT EDIT.
+
+package horse
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[AptitudeLvG-1]
+	_ = x[AptitudeLvF-2]
+	_ = x[AptitudeLvE-3]
+	_ = x[AptitudeLvD-4]
+	_ = x[AptitudeLvC-5]
+	_ = x[AptitudeLvB-6]
+	_ = x[AptitudeLvA-7]
+	_ = x[AptitudeLvS-8]
+}
+
+const _AptitudeLevel_name = "GFEDCBAS"
+
+var _AptitudeLevel_index = [...]uint8{0, 1, 2, 3, 4, 5, 6, 7, 8}
+
+func (i AptitudeLevel) String() string {
+	idx := int(i) - 1
+	if i < 1 || idx >= len(_AptitudeLevel_index)-1 {
+		return "AptitudeLevel(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+	return _AptitudeLevel_name[_AptitudeLevel_index[idx]:_AptitudeLevel_index[idx+1]]
+}

horse/character.go

@@ -3,10 +3,57 @@ package horse
 type CharacterID int16
 
 type Character struct {
-	ID   CharacterID
-	Name string
+	ID   CharacterID `json:"chara_id"`
+	Name string      `json:"name"`
 }
 
 func (c Character) String() string {
 	return c.Name
 }
+
+type AffinityRelation struct {
+	IDA      int `json:"chara_a"`
+	IDB      int `json:"chara_b"`
+	IDC      int `json:"chara_c,omitzero"`
+	Affinity int `json:"affinity"`
+}
+
+// Conversation describes a lobby conversation.
+type Conversation struct {
+	// CharacterID is the ID of the character who has the conversation as
+	// a gallery entry.
+	CharacterID CharacterID `json:"chara_id"`
+	// Number is the conversation number within the character's gallery.
+	Number int `json:"number"`
+	// Location is the ID of the location the conversation occurs in the lobby.
+	Location LobbyConversationLocationID `json:"location"`
+	// LocationName is the name of the lobby location, for convenience.
+	LocationName string `json:"location_name"`
+	// Chara1 is the first conversation participant ID.
+	// It does not necessarily match CharacterID.
+	Chara1 CharacterID `json:"chara_1"`
+	// Chara2 is the second conversation participant ID.
+	Chara2 CharacterID `json:"chara_2,omitzero"`
+	// Chara3 is the third conversation participant ID.
+	Chara3 CharacterID `json:"chara_3,omitzero"`
+	// ConditionType is a complete mystery to me.
+	ConditionType int `json:"condition_type"`
+}
+
+type LobbyConversationLocationID int
+
+//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type LobbyConversationLocationID -trimprefix Lobby -linecomment
+const (
+	LobbyRightFront1 LobbyConversationLocationID = 110 // right side front
+	LobbyRightFront2 LobbyConversationLocationID = 120 // right side front
+	LobbyRightFront3 LobbyConversationLocationID = 130 // right side front
+	LobbyLeftTable1  LobbyConversationLocationID = 210 // left side table
+	LobbyLeftTable2  LobbyConversationLocationID = 220 // left side table
+	LobbyBackSeat    LobbyConversationLocationID = 310 // center back seat
+	LobbyPosters1    LobbyConversationLocationID = 410 // center posters
+	LobbyPosters2    LobbyConversationLocationID = 420 // center posters
+	LobbyPosters3    LobbyConversationLocationID = 430 // center posters
+	LobbySchoolMap1  LobbyConversationLocationID = 510 // left side school map
+	LobbySchoolMap2  LobbyConversationLocationID = 520 // left side school map
+	LobbySchoolMap3  LobbyConversationLocationID = 530 // left side school map
+)

horse/durscale_string.go

@@ -0,0 +1,38 @@
+// Code generated by "stringer -type DurScale -trimprefix Duration -linecomment"; DO NOT EDIT.
+
+package horse
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[DurationDirect-1]
+	_ = x[DurationFrontDistance-2]
+	_ = x[DurationRemainingHP-3]
+	_ = x[DurationIncrementPass-4]
+	_ = x[DurationMidSideBlock-5]
+	_ = x[DurationRemainingHP2-7]
+}
+
+const (
+	_DurScale_name_0 = "directlyscaling with distance from the frontscaling with remaining HPincreasing with each pass while activescaling with mid-race phase blocked side time"
+	_DurScale_name_1 = "scaling with remaining HP"
+)
+
+var (
+	_DurScale_index_0 = [...]uint8{0, 8, 44, 69, 107, 152}
+)
+
+func (i DurScale) String() string {
+	switch {
+	case 1 <= i && i <= 5:
+		i -= 1
+		return _DurScale_name_0[_DurScale_index_0[i]:_DurScale_index_0[i+1]]
+	case i == 7:
+		return _DurScale_name_1
+	default:
+		return "DurScale(" + strconv.FormatInt(int64(i), 10) + ")"
+	}
+}

horse/game-id.kk

@@ -17,7 +17,7 @@ pub struct character-id
 
 // Game ID for trainees, i.e. costume instances of characters.
 // Generally a character ID with two digits appended.
-pub struct trainee-id
+pub struct uma-id
   game-id: game-id
 
 // Game ID for skills.
@@ -74,3 +74,7 @@ pub inline fun (==)(x: a, y: a, ?a/game-id: (a) -> game-id): bool
 // Check whether a game ID is valid, i.e. nonzero.
 pub inline fun is-valid(x: a, ?a/game-id: (a) -> game-id): bool
   x.game-id != 0
+
+// Construct an invalid game ID.
+pub inline fun default/game-id(): game-id
+  0

horse/global.kk

@@ -0,0 +1,8 @@
+module horse/global
+
+import horse/game-id
+
+// Shared saddle affinity bonus.
+// `s` should be the complete list of all saddles shared between the veterans.
+pub fun saddle-bonus(s: list<saddle-id>): int
+  s.length

horse/global/saddle.kk

@@ -1,985 +0,0 @@
-module horse/global/saddle
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import horse/game-id
-pub import horse/race
-pub import horse/global/race
-
-// Enumeration of all saddles for type-safe programming.
-pub type saddle
-  Classic-Triple-Crown
-  Senior-Autumn-Triple-Crown
-  Triple-Tiara
-  Senior-Spring-Triple-Crown
-  Tenno-Sweep
-  Dual-Grand-Prix
-  Dual-Miles
-  Dual-Sprints
-  Dual-Dirts
-  Arima-Kinen
-  Japan-C
-  Japanese-Derby
-  Tenno-Sho-Spring
-  Takarazuka-Kinen
-  Tenno-Sho-Autumn
-  Kikuka-Sho
-  Osaka-Hai
-  Satsuki-Sho
-  Japanese-Oaks
-  Takamatsunomiya-Kinen
-  Yasuda-Kinen
-  Sprinters-S
-  Mile-Ch
-  Oka-Sho
-  Victoria-Mile
-  Queen-Elizabeth-II-Cup
-  NHK-Mile-C
-  Shuka-Sho
-  Champions-C
-  February-S
-  JBC-Classic
-  Tokyo-Daishoten
-  Asahi-Hai-FS
-  Hopeful-S
-  Hanshin-JF
-  Teio-Sho
-  JBC-Sprint
-  JD-Derby
-  JBC-L-Classic
-  Nikkei-Shinshun-Hai
-  Tokai-S
-  American-JCC
-  Kyoto-Kinen
-  Nakayama-Kinen
-  Yayoi-Sho
-  Kinko-Sho
-  Fillies-Revue
-  Hanshin-Daishoten
-  Spring-S
-  Nikkei-Sho
-  Hanshin-Umamusume-S
-  New-Zealand-T
-  Yomiuri-Milers-C
-  Flora-S
-  Aoba-Sho
-  Kyoto-Shimbun-Hai
-  Keio-Hai-Spring-C
-  Meguro-Kinen
-  Sapporo-Kinen
-  Centaur-S
-  Rose-S
-  St-Lite-Kinen
-  Kobe-Shimbun-Hai
-  All-Comers
-  Mainichi-Okan
-  Kyoto-Daishoten
-  Fuchu-Umamusume-S
-  Swan-S
-  Keio-Hai-Junior-S
-  Copa-Republica-Argentina
-  Daily-Hai-Junior-S
-  Stayers-S
-  Hanshin-C
-  Kyoto-Kimpai
-  Nakayama-Kimpai
-  Shinzan-Kinen
-  Fairy-S
-  Aichi-Hai
-  Keisei-Hai
-  Silk-Road-S
-  Negishi-S
-  Kisaragi-Sho
-  Tokyo-Shimbun-Hai
-  Queen-C
-  Kyodo-News-Hai
-  Kyoto-Umamusume-S
-  Diamond-S
-  Kokura-Daishoten
-  Arlington-C
-  Hankyu-Hai
-  Tulip-Sho
-  Ocean-S
-  Nakayama-Umamusume-S
-  Falcon-S
-  Flower-C
-  Mainichi-Hai
-  March-S
-  Lord-Derby-CT
-  Antares-S
-  Fukushima-Umamusume-S
-  Niigata-Daishoten
-  Heian-S
-  Naruo-Kinen
-  Mermaid-S
-  Epsom-C
-  Unicorn-S
-  Hakodate-Sprint-S
-  CBC-Sho
-  Radio-Nikkei-Sho
-  Procyon-S
-  Tanabata-Sho
-  Hakodate-Kinen
-  Chukyo-Kinen
-  Hakodate-Junior-S
-  Ibis-Summer-D
-  Queen-S
-  Kokura-Kinen
-  Leopard-S
-  Sekiya-Kinen
-  Elm-S
-  Kitakyushu-Kinen
-  Niigata-Junior-S
-  Keeneland-C
-  Sapporo-Junior-S
-  Kokura-Junior-S
-  Niigata-Kinen
-  Shion-S
-  Keisei-Hai-AH
-  Sirius-S
-  Saudi-Arabia-RC
-  Fuji-S
-  Artemis-S
-  Fantasy-S
-  Miyako-S
-  Musashino-S
-  Fukushima-Kinen
-  Tokyo-Sports-Hai-Junior-S
-  Kyoto-Junior-S
-  Keihan-Hai
-  Challenge-C
-  Chunichi-Shimbun-Hai
-  Capella-S
-  Turquoise-S
-  Classic-Triple-Crown-Alt144
-  Senior-Spring-Triple-Crown-Alt145
-  Dual-Grand-Prix-Alt146
-  Takarazuka-Kinen-Alt147
-  Kikuka-Sho-Alt148
-  Spring-S-Alt149
-  Aoi-S
-  Senior-Spring-Triple-Crown-Alt151
-  Tenno-Sweep-Alt152
-  Tenno-Sho-Spring-Alt153
-  Classic-Triple-Crown-Alt154
-  Satsuki-Sho-Alt155
-
-// Get the saddle ID for a saddle.
-pub fun saddle-id(s: saddle): saddle-id
-  match s
-    Classic-Triple-Crown -> Saddle-id(1)
-    Senior-Autumn-Triple-Crown -> Saddle-id(2)
-    Triple-Tiara -> Saddle-id(3)
-    Senior-Spring-Triple-Crown -> Saddle-id(4)
-    Tenno-Sweep -> Saddle-id(5)
-    Dual-Grand-Prix -> Saddle-id(6)
-    Dual-Miles -> Saddle-id(7)
-    Dual-Sprints -> Saddle-id(8)
-    Dual-Dirts -> Saddle-id(9)
-    Arima-Kinen -> Saddle-id(10)
-    Japan-C -> Saddle-id(11)
-    Japanese-Derby -> Saddle-id(12)
-    Tenno-Sho-Spring -> Saddle-id(13)
-    Takarazuka-Kinen -> Saddle-id(14)
-    Tenno-Sho-Autumn -> Saddle-id(15)
-    Kikuka-Sho -> Saddle-id(16)
-    Osaka-Hai -> Saddle-id(17)
-    Satsuki-Sho -> Saddle-id(18)
-    Japanese-Oaks -> Saddle-id(19)
-    Takamatsunomiya-Kinen -> Saddle-id(20)
-    Yasuda-Kinen -> Saddle-id(21)
-    Sprinters-S -> Saddle-id(22)
-    Mile-Ch -> Saddle-id(23)
-    Oka-Sho -> Saddle-id(24)
-    Victoria-Mile -> Saddle-id(25)
-    Queen-Elizabeth-II-Cup -> Saddle-id(26)
-    NHK-Mile-C -> Saddle-id(27)
-    Shuka-Sho -> Saddle-id(28)
-    Champions-C -> Saddle-id(29)
-    February-S -> Saddle-id(30)
-    JBC-Classic -> Saddle-id(31)
-    Tokyo-Daishoten -> Saddle-id(32)
-    Asahi-Hai-FS -> Saddle-id(33)
-    Hopeful-S -> Saddle-id(34)
-    Hanshin-JF -> Saddle-id(35)
-    Teio-Sho -> Saddle-id(36)
-    JBC-Sprint -> Saddle-id(37)
-    JD-Derby -> Saddle-id(38)
-    JBC-L-Classic -> Saddle-id(39)
-    Nikkei-Shinshun-Hai -> Saddle-id(40)
-    Tokai-S -> Saddle-id(41)
-    American-JCC -> Saddle-id(42)
-    Kyoto-Kinen -> Saddle-id(43)
-    Nakayama-Kinen -> Saddle-id(44)
-    Yayoi-Sho -> Saddle-id(45)
-    Kinko-Sho -> Saddle-id(46)
-    Fillies-Revue -> Saddle-id(47)
-    Hanshin-Daishoten -> Saddle-id(48)
-    Spring-S -> Saddle-id(49)
-    Nikkei-Sho -> Saddle-id(50)
-    Hanshin-Umamusume-S -> Saddle-id(51)
-    New-Zealand-T -> Saddle-id(52)
-    Yomiuri-Milers-C -> Saddle-id(53)
-    Flora-S -> Saddle-id(54)
-    Aoba-Sho -> Saddle-id(55)
-    Kyoto-Shimbun-Hai -> Saddle-id(56)
-    Keio-Hai-Spring-C -> Saddle-id(57)
-    Meguro-Kinen -> Saddle-id(58)
-    Sapporo-Kinen -> Saddle-id(59)
-    Centaur-S -> Saddle-id(60)
-    Rose-S -> Saddle-id(61)
-    St-Lite-Kinen -> Saddle-id(62)
-    Kobe-Shimbun-Hai -> Saddle-id(63)
-    All-Comers -> Saddle-id(64)
-    Mainichi-Okan -> Saddle-id(65)
-    Kyoto-Daishoten -> Saddle-id(66)
-    Fuchu-Umamusume-S -> Saddle-id(67)
-    Swan-S -> Saddle-id(68)
-    Keio-Hai-Junior-S -> Saddle-id(69)
-    Copa-Republica-Argentina -> Saddle-id(70)
-    Daily-Hai-Junior-S -> Saddle-id(71)
-    Stayers-S -> Saddle-id(72)
-    Hanshin-C -> Saddle-id(73)
-    Kyoto-Kimpai -> Saddle-id(74)
-    Nakayama-Kimpai -> Saddle-id(75)
-    Shinzan-Kinen -> Saddle-id(76)
-    Fairy-S -> Saddle-id(77)
-    Aichi-Hai -> Saddle-id(78)
-    Keisei-Hai -> Saddle-id(79)
-    Silk-Road-S -> Saddle-id(80)
-    Negishi-S -> Saddle-id(81)
-    Kisaragi-Sho -> Saddle-id(82)
-    Tokyo-Shimbun-Hai -> Saddle-id(83)
-    Queen-C -> Saddle-id(84)
-    Kyodo-News-Hai -> Saddle-id(85)
-    Kyoto-Umamusume-S -> Saddle-id(86)
-    Diamond-S -> Saddle-id(87)
-    Kokura-Daishoten -> Saddle-id(88)
-    Arlington-C -> Saddle-id(89)
-    Hankyu-Hai -> Saddle-id(90)
-    Tulip-Sho -> Saddle-id(91)
-    Ocean-S -> Saddle-id(92)
-    Nakayama-Umamusume-S -> Saddle-id(93)
-    Falcon-S -> Saddle-id(94)
-    Flower-C -> Saddle-id(95)
-    Mainichi-Hai -> Saddle-id(96)
-    March-S -> Saddle-id(97)
-    Lord-Derby-CT -> Saddle-id(98)
-    Antares-S -> Saddle-id(99)
-    Fukushima-Umamusume-S -> Saddle-id(100)
-    Niigata-Daishoten -> Saddle-id(101)
-    Heian-S -> Saddle-id(102)
-    Naruo-Kinen -> Saddle-id(103)
-    Mermaid-S -> Saddle-id(104)
-    Epsom-C -> Saddle-id(105)
-    Unicorn-S -> Saddle-id(106)
-    Hakodate-Sprint-S -> Saddle-id(107)
-    CBC-Sho -> Saddle-id(108)
-    Radio-Nikkei-Sho -> Saddle-id(109)
-    Procyon-S -> Saddle-id(110)
-    Tanabata-Sho -> Saddle-id(111)
-    Hakodate-Kinen -> Saddle-id(112)
-    Chukyo-Kinen -> Saddle-id(113)
-    Hakodate-Junior-S -> Saddle-id(114)
-    Ibis-Summer-D -> Saddle-id(115)
-    Queen-S -> Saddle-id(116)
-    Kokura-Kinen -> Saddle-id(117)
-    Leopard-S -> Saddle-id(118)
-    Sekiya-Kinen -> Saddle-id(119)
-    Elm-S -> Saddle-id(120)
-    Kitakyushu-Kinen -> Saddle-id(121)
-    Niigata-Junior-S -> Saddle-id(122)
-    Keeneland-C -> Saddle-id(123)
-    Sapporo-Junior-S -> Saddle-id(124)
-    Kokura-Junior-S -> Saddle-id(125)
-    Niigata-Kinen -> Saddle-id(126)
-    Shion-S -> Saddle-id(127)
-    Keisei-Hai-AH -> Saddle-id(128)
-    Sirius-S -> Saddle-id(129)
-    Saudi-Arabia-RC -> Saddle-id(130)
-    Fuji-S -> Saddle-id(131)
-    Artemis-S -> Saddle-id(132)
-    Fantasy-S -> Saddle-id(133)
-    Miyako-S -> Saddle-id(134)
-    Musashino-S -> Saddle-id(135)
-    Fukushima-Kinen -> Saddle-id(136)
-    Tokyo-Sports-Hai-Junior-S -> Saddle-id(137)
-    Kyoto-Junior-S -> Saddle-id(138)
-    Keihan-Hai -> Saddle-id(139)
-    Challenge-C -> Saddle-id(140)
-    Chunichi-Shimbun-Hai -> Saddle-id(141)
-    Capella-S -> Saddle-id(142)
-    Turquoise-S -> Saddle-id(143)
-    Classic-Triple-Crown-Alt144 -> Saddle-id(144)
-    Senior-Spring-Triple-Crown-Alt145 -> Saddle-id(145)
-    Dual-Grand-Prix-Alt146 -> Saddle-id(146)
-    Takarazuka-Kinen-Alt147 -> Saddle-id(147)
-    Kikuka-Sho-Alt148 -> Saddle-id(148)
-    Spring-S-Alt149 -> Saddle-id(149)
-    Aoi-S -> Saddle-id(150)
-    Senior-Spring-Triple-Crown-Alt151 -> Saddle-id(151)
-    Tenno-Sweep-Alt152 -> Saddle-id(152)
-    Tenno-Sho-Spring-Alt153 -> Saddle-id(153)
-    Classic-Triple-Crown-Alt154 -> Saddle-id(154)
-    Satsuki-Sho-Alt155 -> Saddle-id(155)
-  
-// List of all saddles in ID order for easy iterating.
-pub val all = [
-  Classic-Triple-Crown,
-  Senior-Autumn-Triple-Crown,
-  Triple-Tiara,
-  Senior-Spring-Triple-Crown,
-  Tenno-Sweep,
-  Dual-Grand-Prix,
-  Dual-Miles,
-  Dual-Sprints,
-  Dual-Dirts,
-  Arima-Kinen,
-  Japan-C,
-  Japanese-Derby,
-  Tenno-Sho-Spring,
-  Takarazuka-Kinen,
-  Tenno-Sho-Autumn,
-  Kikuka-Sho,
-  Osaka-Hai,
-  Satsuki-Sho,
-  Japanese-Oaks,
-  Takamatsunomiya-Kinen,
-  Yasuda-Kinen,
-  Sprinters-S,
-  Mile-Ch,
-  Oka-Sho,
-  Victoria-Mile,
-  Queen-Elizabeth-II-Cup,
-  NHK-Mile-C,
-  Shuka-Sho,
-  Champions-C,
-  February-S,
-  JBC-Classic,
-  Tokyo-Daishoten,
-  Asahi-Hai-FS,
-  Hopeful-S,
-  Hanshin-JF,
-  Teio-Sho,
-  JBC-Sprint,
-  JD-Derby,
-  JBC-L-Classic,
-  Nikkei-Shinshun-Hai,
-  Tokai-S,
-  American-JCC,
-  Kyoto-Kinen,
-  Nakayama-Kinen,
-  Yayoi-Sho,
-  Kinko-Sho,
-  Fillies-Revue,
-  Hanshin-Daishoten,
-  Spring-S,
-  Nikkei-Sho,
-  Hanshin-Umamusume-S,
-  New-Zealand-T,
-  Yomiuri-Milers-C,
-  Flora-S,
-  Aoba-Sho,
-  Kyoto-Shimbun-Hai,
-  Keio-Hai-Spring-C,
-  Meguro-Kinen,
-  Sapporo-Kinen,
-  Centaur-S,
-  Rose-S,
-  St-Lite-Kinen,
-  Kobe-Shimbun-Hai,
-  All-Comers,
-  Mainichi-Okan,
-  Kyoto-Daishoten,
-  Fuchu-Umamusume-S,
-  Swan-S,
-  Keio-Hai-Junior-S,
-  Copa-Republica-Argentina,
-  Daily-Hai-Junior-S,
-  Stayers-S,
-  Hanshin-C,
-  Kyoto-Kimpai,
-  Nakayama-Kimpai,
-  Shinzan-Kinen,
-  Fairy-S,
-  Aichi-Hai,
-  Keisei-Hai,
-  Silk-Road-S,
-  Negishi-S,
-  Kisaragi-Sho,
-  Tokyo-Shimbun-Hai,
-  Queen-C,
-  Kyodo-News-Hai,
-  Kyoto-Umamusume-S,
-  Diamond-S,
-  Kokura-Daishoten,
-  Arlington-C,
-  Hankyu-Hai,
-  Tulip-Sho,
-  Ocean-S,
-  Nakayama-Umamusume-S,
-  Falcon-S,
-  Flower-C,
-  Mainichi-Hai,
-  March-S,
-  Lord-Derby-CT,
-  Antares-S,
-  Fukushima-Umamusume-S,
-  Niigata-Daishoten,
-  Heian-S,
-  Naruo-Kinen,
-  Mermaid-S,
-  Epsom-C,
-  Unicorn-S,
-  Hakodate-Sprint-S,
-  CBC-Sho,
-  Radio-Nikkei-Sho,
-  Procyon-S,
-  Tanabata-Sho,
-  Hakodate-Kinen,
-  Chukyo-Kinen,
-  Hakodate-Junior-S,
-  Ibis-Summer-D,
-  Queen-S,
-  Kokura-Kinen,
-  Leopard-S,
-  Sekiya-Kinen,
-  Elm-S,
-  Kitakyushu-Kinen,
-  Niigata-Junior-S,
-  Keeneland-C,
-  Sapporo-Junior-S,
-  Kokura-Junior-S,
-  Niigata-Kinen,
-  Shion-S,
-  Keisei-Hai-AH,
-  Sirius-S,
-  Saudi-Arabia-RC,
-  Fuji-S,
-  Artemis-S,
-  Fantasy-S,
-  Miyako-S,
-  Musashino-S,
-  Fukushima-Kinen,
-  Tokyo-Sports-Hai-Junior-S,
-  Kyoto-Junior-S,
-  Keihan-Hai,
-  Challenge-C,
-  Chunichi-Shimbun-Hai,
-  Capella-S,
-  Turquoise-S,
-  Classic-Triple-Crown-Alt144,
-  Senior-Spring-Triple-Crown-Alt145,
-  Dual-Grand-Prix-Alt146,
-  Takarazuka-Kinen-Alt147,
-  Kikuka-Sho-Alt148,
-  Spring-S-Alt149,
-  Aoi-S,
-  Senior-Spring-Triple-Crown-Alt151,
-  Tenno-Sweep-Alt152,
-  Tenno-Sho-Spring-Alt153,
-  Classic-Triple-Crown-Alt154,
-  Satsuki-Sho-Alt155,
-]
-
-// Get the name for a saddle.
-// Alternate versions of saddles have an indication of their ID in their names.
-// If no saddle matches the ID, the result contains the numeric ID.
-pub fun show(s: saddle-id): string
-  match s.game-id
-    1 -> "Classic Triple Crown"
-    2 -> "Senior Autumn Triple Crown"
-    3 -> "Triple Tiara"
-    4 -> "Senior Spring Triple Crown"
-    5 -> "Tenno Sweep"
-    6 -> "Dual Grand Prix"
-    7 -> "Dual Miles"
-    8 -> "Dual Sprints"
-    9 -> "Dual Dirts"
-    10 -> "Arima Kinen"
-    11 -> "Japan C."
-    12 -> "Japanese Derby"
-    13 -> "Tenno Sho (Spring)"
-    14 -> "Takarazuka Kinen"
-    15 -> "Tenno Sho (Autumn)"
-    16 -> "Kikuka Sho"
-    17 -> "Osaka Hai"
-    18 -> "Satsuki Sho"
-    19 -> "Japanese Oaks"
-    20 -> "Takamatsunomiya Kinen"
-    21 -> "Yasuda Kinen"
-    22 -> "Sprinters S."
-    23 -> "Mile Ch."
-    24 -> "Oka Sho"
-    25 -> "Victoria Mile"
-    26 -> "Queen Elizabeth II Cup"
-    27 -> "NHK Mile C."
-    28 -> "Shuka Sho"
-    29 -> "Champions C."
-    30 -> "February S."
-    31 -> "JBC Classic"
-    32 -> "Tokyo Daishoten"
-    33 -> "Asahi Hai F.S."
-    34 -> "Hopeful S."
-    35 -> "Hanshin J.F."
-    36 -> "Teio Sho"
-    37 -> "JBC Sprint"
-    38 -> "J.D. Derby"
-    39 -> "JBC L. Classic"
-    40 -> "Nikkei Shinshun Hai"
-    41 -> "Tokai S."
-    42 -> "American JCC"
-    43 -> "Kyoto Kinen"
-    44 -> "Nakayama Kinen"
-    45 -> "Yayoi Sho"
-    46 -> "Kinko Sho"
-    47 -> "Fillies' Revue"
-    48 -> "Hanshin Daishoten"
-    49 -> "Spring S."
-    50 -> "Nikkei Sho"
-    51 -> "Hanshin Umamusume S."
-    52 -> "New Zealand T."
-    53 -> "Yomiuri Milers C."
-    54 -> "Flora S."
-    55 -> "Aoba Sho"
-    56 -> "Kyoto Shimbun Hai"
-    57 -> "Keio Hai Spring C."
-    58 -> "Meguro Kinen"
-    59 -> "Sapporo Kinen"
-    60 -> "Centaur S."
-    61 -> "Rose S."
-    62 -> "St. Lite Kinen"
-    63 -> "Kobe Shimbun Hai"
-    64 -> "All Comers"
-    65 -> "Mainichi Okan"
-    66 -> "Kyoto Daishoten"
-    67 -> "Fuchu Umamusume S."
-    68 -> "Swan S."
-    69 -> "Keio Hai Junior S."
-    70 -> "Copa Republica Argentina"
-    71 -> "Daily Hai Junior S."
-    72 -> "Stayers S."
-    73 -> "Hanshin C."
-    74 -> "Kyoto Kimpai"
-    75 -> "Nakayama Kimpai"
-    76 -> "Shinzan Kinen"
-    77 -> "Fairy S."
-    78 -> "Aichi Hai"
-    79 -> "Keisei Hai"
-    80 -> "Silk Road S."
-    81 -> "Negishi S."
-    82 -> "Kisaragi Sho"
-    83 -> "Tokyo Shimbun Hai"
-    84 -> "Queen C."
-    85 -> "Kyodo News Hai"
-    86 -> "Kyoto Umamusume S."
-    87 -> "Diamond S."
-    88 -> "Kokura Daishoten"
-    89 -> "Arlington C."
-    90 -> "Hankyu Hai"
-    91 -> "Tulip Sho"
-    92 -> "Ocean S."
-    93 -> "Nakayama Umamusume S."
-    94 -> "Falcon S."
-    95 -> "Flower C."
-    96 -> "Mainichi Hai"
-    97 -> "March S."
-    98 -> "Lord Derby C.T."
-    99 -> "Antares S."
-    100 -> "Fukushima Umamusume S."
-    101 -> "Niigata Daishoten"
-    102 -> "Heian S."
-    103 -> "Naruo Kinen"
-    104 -> "Mermaid S."
-    105 -> "Epsom C."
-    106 -> "Unicorn S."
-    107 -> "Hakodate Sprint S."
-    108 -> "CBC Sho"
-    109 -> "Radio Nikkei Sho"
-    110 -> "Procyon S."
-    111 -> "Tanabata Sho"
-    112 -> "Hakodate Kinen"
-    113 -> "Chukyo Kinen"
-    114 -> "Hakodate Junior S."
-    115 -> "Ibis Summer D."
-    116 -> "Queen S."
-    117 -> "Kokura Kinen"
-    118 -> "Leopard S."
-    119 -> "Sekiya Kinen"
-    120 -> "Elm S."
-    121 -> "Kitakyushu Kinen"
-    122 -> "Niigata Junior S."
-    123 -> "Keeneland C."
-    124 -> "Sapporo Junior S."
-    125 -> "Kokura Junior S."
-    126 -> "Niigata Kinen"
-    127 -> "Shion S."
-    128 -> "Keisei Hai A.H."
-    129 -> "Sirius S."
-    130 -> "Saudi Arabia R.C."
-    131 -> "Fuji S."
-    132 -> "Artemis S."
-    133 -> "Fantasy S."
-    134 -> "Miyako S."
-    135 -> "Musashino S."
-    136 -> "Fukushima Kinen"
-    137 -> "Tokyo Sports Hai Junior S."
-    138 -> "Kyoto Junior S."
-    139 -> "Keihan Hai"
-    140 -> "Challenge C."
-    141 -> "Chunichi Shimbun Hai"
-    142 -> "Capella S."
-    143 -> "Turquoise S."
-    144 -> "Classic Triple Crown" ++ " (Alternate 144)"
-    145 -> "Senior Spring Triple Crown" ++ " (Alternate 145)"
-    146 -> "Dual Grand Prix" ++ " (Alternate 146)"
-    147 -> "Takarazuka Kinen" ++ " (Alternate 147)"
-    148 -> "Kikuka Sho" ++ " (Alternate 148)"
-    149 -> "Spring S." ++ " (Alternate 149)"
-    150 -> "Aoi S."
-    151 -> "Senior Spring Triple Crown" ++ " (Alternate 151)"
-    152 -> "Tenno Sweep" ++ " (Alternate 152)"
-    153 -> "Tenno Sho (Spring)" ++ " (Alternate 153)"
-    154 -> "Classic Triple Crown" ++ " (Alternate 154)"
-    155 -> "Satsuki Sho" ++ " (Alternate 155)"
-    x -> "saddle " ++ x.show
-
-// Get the list of races that entitle a horse to a saddle.
-// If no saddle matches the ID, the result is the empty list.
-pub fun races(s: saddle-id): list<race-id>
-  match s.game-id
-    1 -> [Race-id(100501), Race-id(101001), Race-id(101501), ]
-    2 -> [Race-id(101601), Race-id(101901), Race-id(102301), ]
-    3 -> [Race-id(100401), Race-id(100901), Race-id(101401), ]
-    4 -> [Race-id(100301), Race-id(100601), Race-id(101201), ]
-    5 -> [Race-id(100601), Race-id(101601), ]
-    6 -> [Race-id(101201), Race-id(102301), ]
-    7 -> [Race-id(101101), Race-id(101801), ]
-    8 -> [Race-id(101301), Race-id(100201), ]
-    9 -> [Race-id(100101), Race-id(102001), ]
-    10 -> [Race-id(102301), ]
-    11 -> [Race-id(101901), ]
-    12 -> [Race-id(101001), ]
-    13 -> [Race-id(100601), ]
-    14 -> [Race-id(101201), ]
-    15 -> [Race-id(101601), ]
-    16 -> [Race-id(101501), ]
-    17 -> [Race-id(100301), ]
-    18 -> [Race-id(100501), ]
-    19 -> [Race-id(100901), ]
-    20 -> [Race-id(100201), ]
-    21 -> [Race-id(101101), ]
-    22 -> [Race-id(101301), ]
-    23 -> [Race-id(101801), ]
-    24 -> [Race-id(100401), ]
-    25 -> [Race-id(100801), ]
-    26 -> [Race-id(101701), ]
-    27 -> [Race-id(100701), ]
-    28 -> [Race-id(101401), ]
-    29 -> [Race-id(102001), ]
-    30 -> [Race-id(100101), ]
-    31 -> [Race-id(110501), ]
-    32 -> [Race-id(110601), ]
-    33 -> [Race-id(102201), ]
-    34 -> [Race-id(102401), ]
-    35 -> [Race-id(102101), ]
-    36 -> [Race-id(110101), ]
-    37 -> [Race-id(110401), ]
-    38 -> [Race-id(110201), ]
-    39 -> [Race-id(110301), ]
-    40 -> [Race-id(200101), ]
-    41 -> [Race-id(200201), ]
-    42 -> [Race-id(200301), ]
-    43 -> [Race-id(200401), ]
-    44 -> [Race-id(200501), ]
-    45 -> [Race-id(200601), ]
-    46 -> [Race-id(200701), ]
-    47 -> [Race-id(200801), ]
-    48 -> [Race-id(200901), ]
-    49 -> [Race-id(201001), ]
-    50 -> [Race-id(201101), ]
-    51 -> [Race-id(201201), ]
-    52 -> [Race-id(201301), ]
-    53 -> [Race-id(201401), ]
-    54 -> [Race-id(201501), ]
-    55 -> [Race-id(201601), ]
-    56 -> [Race-id(201701), ]
-    57 -> [Race-id(201801), ]
-    58 -> [Race-id(201901), ]
-    59 -> [Race-id(202001), ]
-    60 -> [Race-id(202101), ]
-    61 -> [Race-id(202201), ]
-    62 -> [Race-id(202301), ]
-    63 -> [Race-id(202401), ]
-    64 -> [Race-id(202501), ]
-    65 -> [Race-id(202601), ]
-    66 -> [Race-id(202701), ]
-    67 -> [Race-id(202801), ]
-    68 -> [Race-id(202901), ]
-    69 -> [Race-id(203001), ]
-    70 -> [Race-id(203101), ]
-    71 -> [Race-id(203201), ]
-    72 -> [Race-id(203301), ]
-    73 -> [Race-id(203401), ]
-    74 -> [Race-id(300101), ]
-    75 -> [Race-id(300201), ]
-    76 -> [Race-id(300301), ]
-    77 -> [Race-id(300401), ]
-    78 -> [Race-id(300501), ]
-    79 -> [Race-id(300601), ]
-    80 -> [Race-id(300701), ]
-    81 -> [Race-id(300801), ]
-    82 -> [Race-id(300901), ]
-    83 -> [Race-id(301001), ]
-    84 -> [Race-id(301101), ]
-    85 -> [Race-id(301201), ]
-    86 -> [Race-id(301301), ]
-    87 -> [Race-id(301401), ]
-    88 -> [Race-id(301501), ]
-    89 -> [Race-id(301601), ]
-    90 -> [Race-id(301701), ]
-    91 -> [Race-id(301801), ]
-    92 -> [Race-id(301901), ]
-    93 -> [Race-id(302001), ]
-    94 -> [Race-id(302101), ]
-    95 -> [Race-id(302201), ]
-    96 -> [Race-id(302301), ]
-    97 -> [Race-id(302401), ]
-    98 -> [Race-id(302501), ]
-    99 -> [Race-id(302601), ]
-    100 -> [Race-id(302701), ]
-    101 -> [Race-id(302801), ]
-    102 -> [Race-id(302901), ]
-    103 -> [Race-id(303001), ]
-    104 -> [Race-id(303101), ]
-    105 -> [Race-id(303201), ]
-    106 -> [Race-id(303301), ]
-    107 -> [Race-id(303401), ]
-    108 -> [Race-id(303501), ]
-    109 -> [Race-id(303601), ]
-    110 -> [Race-id(303701), ]
-    111 -> [Race-id(303801), ]
-    112 -> [Race-id(303901), ]
-    113 -> [Race-id(304001), ]
-    114 -> [Race-id(304101), ]
-    115 -> [Race-id(304201), ]
-    116 -> [Race-id(304301), ]
-    117 -> [Race-id(304401), ]
-    118 -> [Race-id(304501), ]
-    119 -> [Race-id(304601), ]
-    120 -> [Race-id(304701), ]
-    121 -> [Race-id(304801), ]
-    122 -> [Race-id(304901), ]
-    123 -> [Race-id(305001), ]
-    124 -> [Race-id(305101), ]
-    125 -> [Race-id(305201), ]
-    126 -> [Race-id(305301), ]
-    127 -> [Race-id(305401), ]
-    128 -> [Race-id(305501), ]
-    129 -> [Race-id(305601), ]
-    130 -> [Race-id(305701), ]
-    131 -> [Race-id(305801), ]
-    132 -> [Race-id(305901), ]
-    133 -> [Race-id(306001), ]
-    134 -> [Race-id(306101), ]
-    135 -> [Race-id(306201), ]
-    136 -> [Race-id(306301), ]
-    137 -> [Race-id(306401), ]
-    138 -> [Race-id(306501), ]
-    139 -> [Race-id(306601), ]
-    140 -> [Race-id(306701), ]
-    141 -> [Race-id(306801), ]
-    142 -> [Race-id(306901), ]
-    143 -> [Race-id(307001), ]
-    144 -> [Race-id(100501), Race-id(101001), Race-id(102601), ]
-    145 -> [Race-id(100301), Race-id(100601), Race-id(102501), ]
-    146 -> [Race-id(102501), Race-id(102301), ]
-    147 -> [Race-id(102501), ]
-    148 -> [Race-id(102601), ]
-    149 -> [Race-id(203501), ]
-    150 -> [Race-id(405001), ]
-    151 -> [Race-id(100301), Race-id(102701), Race-id(101201), ]
-    152 -> [Race-id(102701), Race-id(101601), ]
-    153 -> [Race-id(102701), ]
-    154 -> [Race-id(102801), Race-id(101001), Race-id(101501), ]
-    155 -> [Race-id(102801), ]
-    _ -> []
-
-// Get a saddle's type.
-// If no saddle matches the ID, the result is Honor.
-pub fun saddle-type(s: saddle-id): saddle-type
-  match s.game-id
-    1 -> Honor
-    2 -> Honor
-    3 -> Honor
-    4 -> Honor
-    5 -> Honor
-    6 -> Honor
-    7 -> Honor
-    8 -> Honor
-    9 -> Honor
-    10 -> G1-Win
-    11 -> G1-Win
-    12 -> G1-Win
-    13 -> G1-Win
-    14 -> G1-Win
-    15 -> G1-Win
-    16 -> G1-Win
-    17 -> G1-Win
-    18 -> G1-Win
-    19 -> G1-Win
-    20 -> G1-Win
-    21 -> G1-Win
-    22 -> G1-Win
-    23 -> G1-Win
-    24 -> G1-Win
-    25 -> G1-Win
-    26 -> G1-Win
-    27 -> G1-Win
-    28 -> G1-Win
-    29 -> G1-Win
-    30 -> G1-Win
-    31 -> G1-Win
-    32 -> G1-Win
-    33 -> G1-Win
-    34 -> G1-Win
-    35 -> G1-Win
-    36 -> G1-Win
-    37 -> G1-Win
-    38 -> G1-Win
-    39 -> G1-Win
-    40 -> G2-Win
-    41 -> G2-Win
-    42 -> G2-Win
-    43 -> G2-Win
-    44 -> G2-Win
-    45 -> G2-Win
-    46 -> G2-Win
-    47 -> G2-Win
-    48 -> G2-Win
-    49 -> G2-Win
-    50 -> G2-Win
-    51 -> G2-Win
-    52 -> G2-Win
-    53 -> G2-Win
-    54 -> G2-Win
-    55 -> G2-Win
-    56 -> G2-Win
-    57 -> G2-Win
-    58 -> G2-Win
-    59 -> G2-Win
-    60 -> G2-Win
-    61 -> G2-Win
-    62 -> G2-Win
-    63 -> G2-Win
-    64 -> G2-Win
-    65 -> G2-Win
-    66 -> G2-Win
-    67 -> G2-Win
-    68 -> G2-Win
-    69 -> G2-Win
-    70 -> G2-Win
-    71 -> G2-Win
-    72 -> G2-Win
-    73 -> G2-Win
-    74 -> G3-Win
-    75 -> G3-Win
-    76 -> G3-Win
-    77 -> G3-Win
-    78 -> G3-Win
-    79 -> G3-Win
-    80 -> G3-Win
-    81 -> G3-Win
-    82 -> G3-Win
-    83 -> G3-Win
-    84 -> G3-Win
-    85 -> G3-Win
-    86 -> G3-Win
-    87 -> G3-Win
-    88 -> G3-Win
-    89 -> G3-Win
-    90 -> G3-Win
-    91 -> G2-Win
-    92 -> G3-Win
-    93 -> G3-Win
-    94 -> G3-Win
-    95 -> G3-Win
-    96 -> G3-Win
-    97 -> G3-Win
-    98 -> G3-Win
-    99 -> G3-Win
-    100 -> G3-Win
-    101 -> G3-Win
-    102 -> G3-Win
-    103 -> G3-Win
-    104 -> G3-Win
-    105 -> G3-Win
-    106 -> G3-Win
-    107 -> G3-Win
-    108 -> G3-Win
-    109 -> G3-Win
-    110 -> G3-Win
-    111 -> G3-Win
-    112 -> G3-Win
-    113 -> G3-Win
-    114 -> G3-Win
-    115 -> G3-Win
-    116 -> G3-Win
-    117 -> G3-Win
-    118 -> G3-Win
-    119 -> G3-Win
-    120 -> G3-Win
-    121 -> G3-Win
-    122 -> G3-Win
-    123 -> G3-Win
-    124 -> G3-Win
-    125 -> G3-Win
-    126 -> G3-Win
-    127 -> G3-Win
-    128 -> G3-Win
-    129 -> G3-Win
-    130 -> G3-Win
-    131 -> G2-Win
-    132 -> G3-Win
-    133 -> G3-Win
-    134 -> G3-Win
-    135 -> G3-Win
-    136 -> G3-Win
-    137 -> G3-Win
-    138 -> G3-Win
-    139 -> G3-Win
-    140 -> G3-Win
-    141 -> G3-Win
-    142 -> G3-Win
-    143 -> G3-Win
-    144 -> Honor
-    145 -> Honor
-    146 -> Honor
-    147 -> G1-Win
-    148 -> G1-Win
-    149 -> G2-Win
-    150 -> G3-Win
-    151 -> Honor
-    152 -> Honor
-    153 -> G1-Win
-    154 -> Honor
-    155 -> G1-Win
-    _ -> Honor
-
-// Get the primary ID for a saddle.
-// For saddles which are the primary version, or if no saddle matches the given ID,
-// the result is the input.
-pub fun primary(s: saddle-id): saddle-id
-  match s.game-id
-    144 -> Saddle-id(1)
-    145 -> Saddle-id(4)
-    146 -> Saddle-id(6)
-    147 -> Saddle-id(14)
-    148 -> Saddle-id(16)
-    149 -> Saddle-id(49)
-    151 -> Saddle-id(4)
-    152 -> Saddle-id(5)
-    153 -> Saddle-id(13)
-    154 -> Saddle-id(1)
-    155 -> Saddle-id(18)
-    _ -> s

horse/global/scenario.go

@@ -1,23 +0,0 @@
-package global
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import . "git.sunturtle.xyz/zephyr/horse/horse"
-
-const (
-	ScenarioURAFinale ScenarioID = 1 // URA Finale
-	ScenarioUnityCup  ScenarioID = 2 // Unity Cup
-)
-
-var AllScenarios = map[ScenarioID]Scenario{
-	ScenarioURAFinale: {
-		ID:    1,
-		Name:  "URA Finale",
-		Title: "The Beginning: URA Finale",
-	},
-	ScenarioUnityCup: {
-		ID:    2,
-		Name:  "Unity Cup",
-		Title: "Unity Cup: Shine On, Team Spirit!",
-	},
-}

horse/global/scenario.kk

@@ -1,38 +0,0 @@
-module horse/global/scenario
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import horse/game-id
-
-// Enumeration of all scenarios for type-safe programming.
-pub type scenario
-  URA-Finale
-  Unity-Cup
-
-// Get the scenario ID for a scenario.
-pub fun scenario-id(s: scenario): scenario-id
-  match s
-    URA-Finale -> Scenario-id(1)
-    Unity-Cup -> Scenario-id(2)
-  
-// List of all scenarios in ID order for easy iterating.
-pub val all = [
-  URA-Finale,
-  Unity-Cup,
-]
-
-// Get the name for a scenario.
-// If no scenario matches the ID, the result contains the numeric ID.
-pub fun show(s: scenario-id): string
-  match s.game-id
-    1 -> "URA Finale"
-    2 -> "Unity Cup"
-    x -> "scenario " ++ x.show
-
-// Get the full title for a scenario, e.g. "The Beginning: URA Finale".
-// If no scenario matches the ID, the result contains the numeric ID.
-pub fun title(s: scenario-id): string
-  match s.game-id
-    1 -> "The Beginning: URA Finale"
-    2 -> "Unity Cup: Shine On, Team Spirit!"
-    x -> "scenario " ++ x.show

horse/legacy.kk

@@ -1,18 +1,124 @@
 module horse/legacy
 
-import horse/character
+import std/num/decimal
+import std/data/linearmap
+import std/data/linearset
 import horse/game-id
-import horse/race
 import horse/spark
+import horse/prob/dist
 
+// A legacy, or parent and grandparents.
 pub struct legacy
   uma: veteran
-  parents: (veteran, veteran)
+  sub1: veteran
+  sub2: veteran
 
+// A veteran, or the result of a completed career.
 pub struct veteran
-  character: character-id
-  stat: spark<stat>
-  aptitude: spark<aptitude>
-  unique: maybe<spark<unique>>
-  generic: list<spark<generic>>
+  uma: uma-id
+  sparks: list<spark-id>
   saddles: list<saddle-id>
+
+// Get all saddles shared between two lists thereof.
+pub fun shared-saddles(a: list<saddle-id>, b: list<saddle-id>): list<saddle-id>
+  val sa: linearSet<saddle-id> = a.foldl(linear-set(Nil)) fn(s, id) if id.is-valid then s.add(id) else s
+  val c: linearSet<saddle-id> = b.foldl(linear-set(Nil)) fn(s, id) if sa.member(id) then s.add(id) else s
+  c.list
+
+// Get the individual affinity for a legacy.
+// Any invalid ID is treated as giving 0.
+pub fun parent-affinity(
+  trainee: uma-id,
+  legacy: legacy,
+  other-parent: uma-id,
+  ?character-id: (uma-id) -> character-id,
+  ?saddle-bonus: (list<saddle-id>) -> int,
+  ?pair-affinity: (a: character-id, b: character-id) -> int,
+  ?trio-affinity: (a: character-id, b: character-id, c: character-id) -> int
+): int
+  val t = trainee.character-id
+  val p1 = legacy.uma.uma.character-id
+  val s1 = legacy.sub1.uma.character-id
+  val s2 = legacy.sub2.uma.character-id
+  val p2 = other-parent.character-id
+  pair-affinity(t, p1) + pair-affinity(p1, p2)
+    + trio-affinity(t, p1, s1) + trio-affinity(t, p1, s2)
+    + saddle-bonus(shared-saddles(legacy.uma.saddles, legacy.sub1.saddles)) + saddle-bonus(shared-saddles(legacy.uma.saddles, legacy.sub2.saddles))
+
+// Get the individual affinities for a legacy's sub-legacies.
+// The first value is the legacy for the `legacy.sub1` and the second is for
+// `legacy.sub2`.
+// Any invalid ID is treated as giving 0.
+pub fun sub-affinity(
+  trainee: uma-id,
+  legacy: legacy,
+  ?character-id: (uma-id) -> character-id,
+  ?saddle-bonus: (list<saddle-id>) -> int,
+  ?trio-affinity: (a: character-id, b: character-id, c: character-id) -> int
+): (int, int)
+  val t = trainee.character-id
+  val p = legacy.uma.uma.character-id
+  val s1 = legacy.sub1.uma.character-id
+  val s2 = legacy.sub2.uma.character-id
+  val r1 = trio-affinity(t, p, s1) + saddle-bonus(shared-saddles(legacy.uma.saddles, legacy.sub1.saddles))
+  val r2 = trio-affinity(t, p, s2) + saddle-bonus(shared-saddles(legacy.uma.saddles, legacy.sub2.saddles))
+  (r1, r2)
+
+// Associate each spark with its actual chance to activate given an individual
+// affinity value and the possible effects when it does.
+pub fun uma/inspiration(l: list<spark-id>, affinity: int, ?spark-type: (spark-id) -> spark-type, ?rarity: (spark-id) -> rarity, ?effects: (spark-id) -> list<list<spark-effect>>): list<(spark-id, decimal, list<list<spark-effect>>)>
+  val a = decimal(1 + affinity, -2)
+  l.map() fn(id) (id, min(id.base-proc * a, 1.decimal), id.effects)
+
+// Get the complete list of effects that may occur in an inspiration event
+// and the respective probability of activation.
+// Duplicates, i.e. multiple veterans with the same spark, are preserved.
+pub fun inspiration(
+  trainee: uma-id,
+  parent1: legacy,
+  parent2: legacy,
+  ?character-id: (uma-id) -> character-id,
+  ?saddle-bonus: (list<saddle-id>) -> int,
+  ?pair-affinity: (a: character-id, b: character-id) -> int,
+  ?trio-affinity: (a: character-id, b: character-id, c: character-id) -> int,
+  ?spark-type: (spark-id) -> spark-type,
+  ?rarity: (spark-id) -> rarity,
+  ?effects: (spark-id) -> list<list<spark-effect>>
+): list<(spark-id, decimal, list<list<spark-effect>>)>
+  val p1a = parent-affinity(trainee, parent1, parent2.uma.uma)
+  val p2a = parent-affinity(trainee, parent2, parent1.uma.uma)
+  val (s11a, s12a) = sub-affinity(trainee, parent1)
+  val (s21a, s22a) = sub-affinity(trainee, parent2)
+  [
+    inspiration(parent1.uma.sparks, p1a),
+    inspiration(parent1.sub1.sparks, s11a),
+    inspiration(parent1.sub2.sparks, s12a),
+    inspiration(parent2.uma.sparks, p2a),
+    inspiration(parent2.sub1.sparks, s21a),
+    inspiration(parent2.sub2.sparks, s22a),
+  ].concat
+
+// Reduce a spark effect list to the skill it is able to give.
+pub fun skills(l: list<list<spark-effect>>): maybe<skill-id>
+  val r: linearSet<skill-id> = l.head(Nil).foldl(linear-set(Nil)) fn(s, eff)
+    match eff
+      Skill-Hint(id, _) -> s + id
+      _ -> s
+  r.list.head
+
+// Reduce a spark effect list to the aptitude it is able to give.
+pub fun aptitudes(l: list<list<spark-effect>>): maybe<aptitude>
+  val r: linearSet<aptitude> = l.head(Nil).foldl(linear-set(Nil)) fn(s, eff)
+    match eff
+      Aptitude-Up(apt) -> s + apt
+      _ -> s
+  r.list.head
+
+// Get the overall chance of each count of sparks, including zero, providing a
+// given type of effect activating in a single inspiration event.
+pub fun inspiration-gives(l: list<(spark-id, decimal, list<list<spark-effect>>)>, f: (list<list<spark-effect>>) -> maybe<a>, ?a/(==): (a, a) -> bool): linearMap<a, list<decimal>>
+  val m: linearMap<_, list<decimal>> = l.foldl(LinearMap(Nil)) fn(m, (_, p, eff))
+    match f(eff)
+      Nothing -> m
+      Just(a) -> m.map/update(a, [p]) fn(cur, pp) pp.append(cur)
+  m.map() fn(_, v) poisson-binomial(v)

horse/lobbyconversationlocationid_string.go

@@ -0,0 +1,47 @@
+// Code generated by "stringer -type LobbyConversationLocationID -trimprefix Lobby -linecomment"; DO NOT EDIT.
+
+package horse
+
+import "strconv"
+
+func _() {
+	// An "invalid array index" compiler error signifies that the constant values have changed.
+	// Re-run the stringer command to generate them again.
+	var x [1]struct{}
+	_ = x[LobbyRightFront1-110]
+	_ = x[LobbyRightFront2-120]
+	_ = x[LobbyRightFront3-130]
+	_ = x[LobbyLeftTable1-210]
+	_ = x[LobbyLeftTable2-220]
+	_ = x[LobbyBackSeat-310]
+	_ = x[LobbyPosters1-410]
+	_ = x[LobbyPosters2-420]
+	_ = x[LobbyPosters3-430]
+	_ = x[LobbySchoolMap1-510]
+	_ = x[LobbySchoolMap2-520]
+	_ = x[LobbySchoolMap3-530]
+}
+
+const _LobbyConversationLocationID_name = "right side frontright side frontright side frontleft side tableleft side tablecenter back seatcenter posterscenter posterscenter postersleft side school mapleft side school mapleft side school map"
+
+var _LobbyConversationLocationID_map = map[LobbyConversationLocationID]string{
+	110: _LobbyConversationLocationID_name[0:16],
+	120: _LobbyConversationLocationID_name[16:32],
+	130: _LobbyConversationLocationID_name[32:48],
+	210: _LobbyConversationLocationID_name[48:63],
+	220: _LobbyConversationLocationID_name[63:78],
+	310: _LobbyConversationLocationID_name[78:94],
+	410: _LobbyConversationLocationID_name[94:108],
+	420: _LobbyConversationLocationID_name[108:122],
+	430: _LobbyConversationLocationID_name[122:136],
+	510: _LobbyConversationLocationID_name[136:156],
+	520: _LobbyConversationLocationID_name[156:176],
+	530: _LobbyConversationLocationID_name[176:196],
+}
+
+func (i LobbyConversationLocationID) String() string {
+	if str, ok := _LobbyConversationLocationID_map[i]; ok {
+		return str
+	}
+	return "LobbyConversationLocationID(" + strconv.FormatInt(int64(i), 10) + ")"
+}

horse/movement.kk

@@ -53,8 +53,8 @@ pub fun style/show(this : style) : e string
     Late-Surger -> "Late Surger"
     End-Closer -> "End Closer"
 
-// Starting aptitude levels.
-pub type level
+// Aptitude levels.
+pub type aptitude-level
   G
   F
   E
@@ -64,36 +64,38 @@ pub type level
   A
   S
 
-// Automatically generated.
-// Comparison of the `level` type.
-pub fun level/cmp(this : level, other : level) : e order
-  match (this, other)
-    (G, G) -> Eq
-    (G, _) -> Lt
-    (_, G) -> Gt
-    (F, F) -> Eq
-    (F, _) -> Lt
-    (_, F) -> Gt
-    (E, E) -> Eq
-    (E, _) -> Lt
-    (_, E) -> Gt
-    (D, D) -> Eq
-    (D, _) -> Lt
-    (_, D) -> Gt
-    (C, C) -> Eq
-    (C, _) -> Lt
-    (_, C) -> Gt
-    (B, B) -> Eq
-    (B, _) -> Lt
-    (_, B) -> Gt
-    (A, A) -> Eq
-    (A, _) -> Lt
-    (_, A) -> Gt
-    (S, S) -> Eq
+// Get the integer value for an aptitude level, starting at G -> 1.
+pub fun aptitude-level/int(l: aptitude-level): int
+  match l
+    G -> 1
+    F -> 2
+    E -> 3
+    D -> 4
+    C -> 5
+    B -> 6
+    A -> 7
+    S -> 8
+
+// Get the aptitude level corresponding to an integer, starting at 1 -> G.
+pub fun int/aptitude-level(l: int): maybe<aptitude-level>
+  match l
+    1 -> Just(G)
+    2 -> Just(F)
+    3 -> Just(E)
+    4 -> Just(D)
+    5 -> Just(C)
+    6 -> Just(B)
+    7 -> Just(A)
+    8 -> Just(S)
+    _ -> Nothing
+
+// Comparison of the `aptitude-level` type.
+pub fun aptitude-level/cmp(this : aptitude-level, other : aptitude-level) : e order
+  cmp(this.int, other.int)
 
 // Automatically generated.
-// Fip comparison of the `level` type.
-pub fun level/order2(this : level, other : level) : order2<level>
+// Fip comparison of the `aptitude-level` type.
+pub fun aptitude-level/order2(this : aptitude-level, other : aptitude-level) : order2<aptitude-level>
   match (this, other)
     (G, G) -> Eq2(G)
     (G, other') -> Lt2(G, other')
@@ -119,8 +121,8 @@ pub fun level/order2(this : level, other : level) : order2<level>
     (S, S) -> Eq2(S)
 
 // Automatically generated.
-// Shows a string representation of the `level` type.
-pub fun level/show(this : level) : string
+// Shows a string representation of the `aptitude-level` type.
+pub fun aptitude-level/show(this : aptitude-level) : string
   match this
     G -> "G"
     F -> "F"

horse/prob/dist.kk

@@ -0,0 +1,21 @@
+module horse/prob/dist
+
+import std/num/decimal
+
+tail fun pb-step(pn: list<decimal>, pi: decimal, pmfkm1: decimal, pmf: list<decimal>, next: ctx<list<decimal>>): list<decimal>
+  match pn
+    Nil -> next ++. Nil // final step overall
+    Cons(_, pp) -> match pmf
+      Cons(pmfk, pmf') ->
+        val next' = next ++ ctx Cons(pi * pmfkm1 + (1.decimal - pi) * pmfk, hole)
+        pb-step(pp, pi, pmfk, pmf', next')
+      Nil -> next ++. Cons(pi * pmfkm1, Nil) // last step of this iteration
+
+// Given `n` different Bernoulli processes with respective probabilities in `pn`,
+// find the distribution of `k` successes for `k` ranging from 0 to `n` inclusive.
+// The index in the result list corresponds to `k`.
+pub fun pmf/poisson-binomial(pn: list<decimal>): list<decimal>
+  pn.foldl([1.decimal]) fn(pmf, pi)
+    match pmf
+      Cons(pmf0, pmf') -> pb-step(pn, pi, pmf0, pmf', ctx Cons((1.decimal - pi) * pmf0, hole))
+      Nil -> impossible("fold started with non-empty pmf but got empty pmf")

horse/race.go

@@ -4,26 +4,26 @@ type RaceID int32
 
 // Race is the internal data about a race.
 type Race struct {
-	ID        RaceID
-	Name      string
-	Thumbnail int
+	ID        RaceID `json:"race_id"`
+	Name      string `json:"name"`
+	Thumbnail int    `json:"thumbnail"`
 	// Some careers contain unusual versions of races, e.g. Tenno Sho (Spring)
 	// in Hanshin instead of Kyoto for Narita Taishin and Biwa Hayahide.
 	// For such races, this field holds the normal race ID.
-	Primary RaceID
+	Primary RaceID `json:"primary"`
 }
 
 type SaddleID int32
 
 // Saddle is the internal data about a race win saddle.
 type Saddle struct {
-	ID    SaddleID
-	Name  string
-	Races []RaceID
-	Type  SaddleType
+	ID    SaddleID   `json:"saddle_id"`
+	Name  string     `json:"name"`
+	Races []RaceID   `json:"races"`
+	Type  SaddleType `json:"type"`
 	// Saddles that involve alternate races are themselves alternate.
 	// For such saddles, this field holds the normal saddle ID.
-	Primary SaddleID
+	Primary SaddleID `json:"primary"`
 }
 
 type SaddleType int8
@@ -40,7 +40,7 @@ type ScenarioID int8
 
 // Scenario is metadata about a career scenario.
 type Scenario struct {
-	ID    ScenarioID
-	Name  string
-	Title string
+	ID    ScenarioID `json:"scenario_id"`
+	Name  string     `json:"name"`
+	Title string     `json:"title"`
 }

horse/skill.go

@@ -27,36 +27,37 @@ func (x TenThousandths) String() string {
 
 // Skill is the internal data about a skill.
 type Skill struct {
-	ID          SkillID
-	Name        string
-	Description string
-	Group       int32
-	Rarity      int8
-	GroupRate   int8
-	GradeValue  int32
-	WitCheck    bool
-	Activations []Activation
-	UniqueOwner string
-	SPCost      int
-	IconID      int
+	ID          SkillID      `json:"skill_id"`
+	Name        string       `json:"name"`
+	Description string       `json:"description"`
+	Group       SkillGroupID `json:"group"`
+	Rarity      int8         `json:"rarity"`
+	GroupRate   int8         `json:"group_rate"`
+	GradeValue  int32        `json:"grade_value,omitzero"`
+	WitCheck    bool         `json:"wit_check"`
+	Activations []Activation `json:"activations"`
+	UniqueOwner string       `json:"unique_owner,omitzero"`
+	SPCost      int          `json:"sp_cost,omitzero"`
+	IconID      int          `json:"icon_id"`
 }
 
 // Activation is the parameters controlling when a skill activates.
 type Activation struct {
-	Precondition string
-	Condition    string
-	Duration     TenThousandths
-	Cooldown     TenThousandths
-	Abilities    []Ability
+	Precondition string         `json:"precondition,omitzero"`
+	Condition    string         `json:"condition"`
+	Duration     TenThousandths `json:"duration,omitzero"`
+	DurScale     DurScale       `json:"dur_scale"`
+	Cooldown     TenThousandths `json:"cooldown,omitzero"`
+	Abilities    []Ability      `json:"abilities"`
 }
 
 // Ability is an individual effect applied by a skill.
 type Ability struct {
-	Type        AbilityType
-	ValueUsage  AbilityValueUsage
-	Value       TenThousandths
-	Target      AbilityTarget
-	TargetValue int32
+	Type        AbilityType       `json:"type"`
+	ValueUsage  AbilityValueUsage `json:"value_usage"`
+	Value       TenThousandths    `json:"value"`
+	Target      AbilityTarget     `json:"target"`
+	TargetValue int32             `json:"target_value,omitzero"`
 }
 
 func (a Ability) String() string {
@@ -126,6 +127,18 @@ func (a Ability) String() string {
 	return string(r)
 }
 
+type DurScale int8
+
+//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type DurScale -trimprefix Duration -linecomment
+const (
+	DurationDirect        DurScale = 1 // directly
+	DurationFrontDistance DurScale = 2 // scaling with distance from the front
+	DurationRemainingHP   DurScale = 3 // scaling with remaining HP
+	DurationIncrementPass DurScale = 4 // increasing with each pass while active
+	DurationMidSideBlock  DurScale = 5 // scaling with mid-race phase blocked side time
+	DurationRemainingHP2  DurScale = 7 // scaling with remaining HP
+)
+
 type AbilityType int8
 
 //go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type AbilityType -trimprefix Ability -linecomment
@@ -189,3 +202,29 @@ const (
 	TargetCharacter     AbilityTarget = 22 // specific character
 	TargetTriggering    AbilityTarget = 23 // whosoever triggered this skill
 )
+
+type SkillGroupID int32
+
+// SkillGroup is a group of skills which are alternate versions of each other.
+//
+// Any of the skill IDs in a group may be zero, indicating that there is no
+// skill with the corresponding group rate.
+// Some skill groups contain only Skill2 or SkillBad, while others may have all
+// four skills.
+//
+// As a special case, horsegen lists both unique skills and their inherited
+// versions in the skill groups for both.
+type SkillGroup struct {
+	ID SkillGroupID `json:"skill_group"`
+	// Skill1 is the base version of the skill, either a common (white) skill
+	// or an Uma's own unique.
+	Skill1 SkillID `json:"skill1,omitzero"`
+	// Skill2 is the first upgraded version of the skill: a rare (gold)
+	// skill, a double circle skill, or an inherited unique skill.
+	Skill2 SkillID `json:"skill2,omitzero"`
+	// Skill3 is the highest upgraded version, a gold version of a skill with
+	// a double circle version.
+	Skill3 SkillID `json:"skill3,omitzero"`
+	// SkillBad is a negative (purple) skill.
+	SkillBad SkillID `json:"skill_bad,omitzero"`
+}

horse/skill.kk

@@ -18,7 +18,7 @@ pub struct skill-detail
   grade-value: int
   wit-check: bool
   activations: list<activation>
-  owner: maybe<trainee-id>
+  owner: maybe<uma-id>
   sp-cost: int
   icon-id: skill-icon-id
 
@@ -32,7 +32,7 @@ pub fun detail(
   ?skill/grade-value: (skill-id) -> int,
   ?skill/wit-check: (skill-id) -> bool,
   ?skill/activations: (skill-id) -> list<activation>,
-  ?skill/unique-owner: (skill-id) -> maybe<trainee-id>,
+  ?skill/unique-owner: (skill-id) -> maybe<uma-id>,
   ?skill/sp-cost: (skill-id) -> int,
   ?skill/icon-id: (skill-id) -> skill-icon-id
 ): skill-detail
@@ -51,13 +51,13 @@ pub fun detail(
     s.icon-id
   )
 
-pub fun skill-detail/show(d: skill-detail, ?character/show: (character-id) -> string, ?trainee/show: (trainee-id) -> string): string
+pub fun skill-detail/show(d: skill-detail, ?character/show: (character-id) -> string, ?uma/show: (uma-id) -> string): string
   val Skill-detail(Skill-id(id), name, desc, _, rarity, _, grade-value, wit-check, activations, owner, sp-cost, _) = d
   val r = name ++ " (ID " ++ id.show ++ "): " ++ desc ++ " " ++ activations.map(activation/show).join(". ") ++ (if wit-check then ". Wit check. " else ". No wit check. ") ++ rarity.show ++ " costing " ++ sp-cost.show ++ " SP, worth " ++ grade-value.show ++ " grade value."
   match owner
     Nothing -> r
     Just(owner-id) -> match owner-id.show
-      "" -> r ++ " Unique skill of trainee with ID " ++ owner-id.show ++ "."
+      "" -> r ++ " Unique skill of Uma with ID " ++ owner-id.show ++ "."
       owner-name -> r ++ " Unique skill of " ++ owner-name ++ "."
 
 // Skill rarity levels.
@@ -85,17 +85,40 @@ pub struct activation
   precondition: condition
   condition: condition
   duration: decimal // seconds
+  dur-scale: dur-scale
   cooldown: decimal // seconds
   abilities: list<ability> // one to three elements
 
 pub fun activation/show(a: activation, ?character/show: (character-id) -> string): string
   match a
-    Activation("", condition, duration, _, abilities)                  | !duration.is-pos        -> condition ++ " -> " ++ abilities.show
-    Activation("", condition, duration, cooldown, abilities)           | cooldown >= 500.decimal -> condition ++ " -> for " ++ duration.show ++ "s, " ++ abilities.show
-    Activation("", condition, duration, cooldown, abilities)                                     -> condition ++ " -> for " ++ duration.show ++ "s on " ++ cooldown.show ++ "s cooldown, " ++ abilities.show
-    Activation(precondition, condition, duration, _, abilities)        | !duration.is-pos        -> precondition ++ " -> " ++ condition ++ " -> " ++ abilities.show
-    Activation(precondition, condition, duration, cooldown, abilities) | cooldown >= 500.decimal -> precondition ++ " -> " ++ condition ++ " -> for " ++ duration.show ++ "s, " ++ abilities.show
-    Activation(precondition, condition, duration, cooldown, abilities)                           -> precondition ++ " -> " ++ condition ++ " -> for " ++ duration.show ++ "s on " ++ cooldown.show ++ "s cooldown, " ++ abilities.show
+    Activation("", condition, duration, _, _, abilities)                           | !duration.is-pos        -> condition ++ " -> " ++ abilities.show
+    Activation("", condition, duration, Direct-Dur, cooldown, abilities)           | cooldown >= 500.decimal -> condition ++ " -> for " ++ duration.show ++ "s, " ++ abilities.show
+    Activation("", condition, duration, dur-scale, cooldown, abilities)            | cooldown >= 500.decimal -> condition ++ " -> for " ++ duration.show ++ "s " ++ dur-scale.show ++ ", " ++ abilities.show
+    Activation("", condition, duration, Direct-Dur, cooldown, abilities)                                     -> condition ++ " -> for " ++ duration.show ++ "s on " ++ cooldown.show ++ "s cooldown, " ++ abilities.show
+    Activation("", condition, duration, dur-scale, cooldown, abilities)                                      -> condition ++ " -> for " ++ duration.show ++ "s " ++ dur-scale.show ++ " on " ++ cooldown.show ++ "s cooldown, " ++ abilities.show
+    Activation(precondition, condition, duration, _, _, abilities)                 | !duration.is-pos        -> precondition ++ " -> " ++ condition ++ " -> " ++ abilities.show
+    Activation(precondition, condition, duration, Direct-Dur, cooldown, abilities) | cooldown >= 500.decimal -> precondition ++ " -> " ++ condition ++ " -> for " ++ duration.show ++ "s, " ++ abilities.show
+    Activation(precondition, condition, duration, dur-scale, cooldown, abilities)  | cooldown >= 500.decimal -> precondition ++ " -> " ++ condition ++ " -> for " ++ duration.show ++ "s " ++ dur-scale.show ++ ", " ++ abilities.show
+    Activation(precondition, condition, duration, Direct-Dur, cooldown, abilities)                           -> precondition ++ " -> " ++ condition ++ " -> for " ++ duration.show ++ "s on " ++ cooldown.show ++ "s cooldown, " ++ abilities.show
+    Activation(precondition, condition, duration, dur-scale, cooldown, abilities)                            -> precondition ++ " -> " ++ condition ++ " -> for " ++ duration.show ++ "s " ++ dur-scale.show ++ " on " ++ cooldown.show ++ "s cooldown, " ++ abilities.show
+
+// Special scaling types for skill activation durations.
+pub type dur-scale
+  Direct-Dur
+  Front-Distance-Dur
+  Multiply-Remaining-HP
+  Increment-Pass
+  Midrace-Side-Block-Time-Dur
+  Multiply-Remaining-HP2
+
+pub fun dur-scale/show(s: dur-scale): string
+  match s
+    Direct-Dur                  -> "with no scaling"
+    Front-Distance-Dur          -> "scaling with distance from the front"
+    Multiply-Remaining-HP       -> "scaling with remaining HP"
+    Increment-Pass              -> "increasing with each pass while active"
+    Midrace-Side-Block-Time-Dur -> "scaling with mid-race phase blocked side time"
+    Multiply-Remaining-HP2      -> "scaling with remaining HP"
 
 // Effects of activating a skill.
 pub struct ability

horse/skill_test.go

@@ -1,38 +1,11 @@
 package horse_test
 
 import (
-	"cmp"
-	"slices"
-	"strings"
-	"sync"
 	"testing"
 
 	"git.sunturtle.xyz/zephyr/horse/horse"
-	"git.sunturtle.xyz/zephyr/horse/horse/global"
 )
 
-var SortedSkills = sync.OnceValue(func() []horse.Skill {
-	skills := make([]horse.Skill, 0, len(global.AllSkills))
-	for _, v := range global.AllSkills {
-		skills = append(skills, v)
-	}
-	slices.SortFunc(skills, func(a, b horse.Skill) int { return cmp.Compare(a.ID, b.ID) })
-	return skills
-})
-
-func TestSkillStrings(t *testing.T) {
-	t.Parallel()
-	for _, s := range SortedSkills() {
-		for _, a := range s.Activations {
-			for _, abil := range a.Abilities {
-				if n := abil.Type.String(); strings.HasPrefix(n, "AbilityType(") {
-					t.Errorf("%v %s: %s", s.ID, s.Name, n)
-				}
-			}
-		}
-	}
-}
-
 func TestTenThousandthsString(t *testing.T) {
 	t.Parallel()
 	cases := []struct {

horse/spark.go

@@ -6,13 +6,13 @@ type (
 )
 
 type Spark struct {
-	ID          SparkID
-	Name        string
-	Description string
-	Group       SparkGroupID
-	Rarity      SparkRarity
-	Type        SparkType
-	Effects     [][]SparkEffect
+	ID          SparkID         `json:"spark_id"`
+	Name        string          `json:"name"`
+	Description string          `json:"description"`
+	Group       SparkGroupID    `json:"spark_group"`
+	Rarity      SparkRarity     `json:"rarity"`
+	Type        SparkType       `json:"type"`
+	Effects     [][]SparkEffect `json:"effects"`
 }
 
 type SparkType int8
@@ -46,9 +46,9 @@ func (r SparkRarity) String() string {
 }
 
 type SparkEffect struct {
-	Target SparkTarget
-	Value1 int32
-	Value2 int32
+	Target SparkTarget `json:"target"`
+	Value1 int32       `json:"value1,omitzero"`
+	Value2 int32       `json:"value2,omitzero"`
 }
 
 type SparkTarget int8

horse/spark.kk

@@ -10,6 +10,9 @@ pub struct spark-detail
   typ: spark-type
   rarity: rarity
 
+pub fun detail(id: spark-id, ?spark/spark-type: (spark-id) -> spark-type, ?spark/rarity: (spark-id) -> rarity): spark-detail
+  Spark-detail(id, id.spark-type, id.rarity)
+
 pub fun spark-detail/show(s: spark-detail, ?spark/show: (spark-id) -> string): string
   s.spark-id.show ++ " " ++ "\u2605".repeat(s.rarity.int)
 
@@ -39,23 +42,25 @@ pub type spark-effect
   Stat-Cap-Up(s: stat, amount: int)
 
 // Get the base probability for a spark to trigger during a single inheritance.
-pub fun decimal/base-proc(s: spark-detail): decimal
-  match s
-    Spark-detail(_, Stat, One) -> 70.decimal(-2)
-    Spark-detail(_, Stat, Two) -> 80.decimal(-2)
-    Spark-detail(_, Stat, Three) -> 90.decimal(-2)
-    Spark-detail(_, Aptitude, One) -> 1.decimal(-2)
-    Spark-detail(_, Aptitude, Two) -> 3.decimal(-2)
-    Spark-detail(_, Aptitude, Three) -> 5.decimal(-2)
-    Spark-detail(_, Unique, One) -> 5.decimal(-2)
-    Spark-detail(_, Unique, Two) -> 10.decimal(-2)
-    Spark-detail(_, Unique, Three) -> 15.decimal(-2)
-    Spark-detail(_, Race, One) -> 1.decimal(-2)
-    Spark-detail(_, Race, Two) -> 2.decimal(-2)
-    Spark-detail(_, Race, Three) -> 3.decimal(-2)
-    Spark-detail(_, _, One) -> 3.decimal(-2)
-    Spark-detail(_, _, Two) -> 6.decimal(-2)
-    Spark-detail(_, _, Three) -> 9.decimal(-2)
+pub fun decimal/base-proc(id: spark-id, ?spark-type: (spark-id) -> spark-type, ?rarity: (spark-id) -> rarity): decimal
+  val t = id.spark-type
+  val r = id.rarity
+  match (t, r)
+    (Stat, One) -> 70.decimal(-2)
+    (Stat, Two) -> 80.decimal(-2)
+    (Stat, Three) -> 90.decimal(-2)
+    (Aptitude, One) -> 1.decimal(-2)
+    (Aptitude, Two) -> 3.decimal(-2)
+    (Aptitude, Three) -> 5.decimal(-2)
+    (Unique, One) -> 5.decimal(-2)
+    (Unique, Two) -> 10.decimal(-2)
+    (Unique, Three) -> 15.decimal(-2)
+    (Race, One) -> 1.decimal(-2)
+    (Race, Two) -> 2.decimal(-2)
+    (Race, Three) -> 3.decimal(-2)
+    (_, One) -> 3.decimal(-2)
+    (_, Two) -> 6.decimal(-2)
+    (_, Three) -> 9.decimal(-2)
 
 // The level or star count of a spark.
 pub type rarity
@@ -106,6 +111,55 @@ pub type aptitude
   Late-Surger
   End-Closer
 
+// Automatically generated.
+// Fip comparison of the `aptitude` type.
+pub fun aptitude/order2(this : aptitude, other : aptitude) : e order2<aptitude>
+  match (this, other)
+    (Turf, Turf) -> Eq2(Turf)
+    (Turf, other') -> Lt2(Turf, other')
+    (this', Turf) -> Gt2(Turf, this')
+    (Dirt, Dirt) -> Eq2(Dirt)
+    (Dirt, other') -> Lt2(Dirt, other')
+    (this', Dirt) -> Gt2(Dirt, this')
+    (Sprint, Sprint) -> Eq2(Sprint)
+    (Sprint, other') -> Lt2(Sprint, other')
+    (this', Sprint) -> Gt2(Sprint, this')
+    (Mile, Mile) -> Eq2(Mile)
+    (Mile, other') -> Lt2(Mile, other')
+    (this', Mile) -> Gt2(Mile, this')
+    (Medium, Medium) -> Eq2(Medium)
+    (Medium, other') -> Lt2(Medium, other')
+    (this', Medium) -> Gt2(Medium, this')
+    (Long, Long) -> Eq2(Long)
+    (Long, other') -> Lt2(Long, other')
+    (this', Long) -> Gt2(Long, this')
+    (Front-Runner, Front-Runner) -> Eq2(Front-Runner)
+    (Front-Runner, other') -> Lt2(Front-Runner, other')
+    (this', Front-Runner) -> Gt2(Front-Runner, this')
+    (Pace-Chaser, Pace-Chaser) -> Eq2(Pace-Chaser)
+    (Pace-Chaser, other') -> Lt2(Pace-Chaser, other')
+    (this', Pace-Chaser) -> Gt2(Pace-Chaser, this')
+    (Late-Surger, Late-Surger) -> Eq2(Late-Surger)
+    (Late-Surger, other') -> Lt2(Late-Surger, other')
+    (this', Late-Surger) -> Gt2(Late-Surger, this')
+    (End-Closer, End-Closer) -> Eq2(End-Closer)
+
+// Automatically generated.
+// Equality comparison of the `aptitude` type.
+pub fun aptitude/(==)(this : aptitude, other : aptitude) : e bool
+  match (this, other)
+    (Turf, Turf) -> True
+    (Dirt, Dirt) -> True
+    (Sprint, Sprint) -> True
+    (Mile, Mile) -> True
+    (Medium, Medium) -> True
+    (Long, Long) -> True
+    (Front-Runner, Front-Runner) -> True
+    (Pace-Chaser, Pace-Chaser) -> True
+    (Late-Surger, Late-Surger) -> True
+    (End-Closer, End-Closer) -> True
+    (_, _) -> False
+
 // Shows a string representation of the `aptitude` type.
 pub fun aptitude/show(this : aptitude): string
   match this

horse/trainee.kk

@@ -1,18 +0,0 @@
-module horse/trainee
-
-import horse/game-id
-import horse/movement
-import horse/race
-
-// Details of a trainee.
-pub struct trainee-detail
-  turf: level
-  dirt: level
-  sprint: level
-  mile: level
-  medium: level
-  long: level
-  front-runner: level
-  pace-chaser: level
-  late-surger: level
-  end-closer: level

horse/uma.go

@@ -0,0 +1,44 @@
+package horse
+
+type UmaID int32
+
+type Uma struct {
+	ID          UmaID       `json:"chara_card_id"`
+	CharacterID CharacterID `json:"chara_id"`
+	Name        string      `json:"name"`
+	Variant     string      `json:"variant"`
+
+	Sprint AptitudeLevel `json:"sprint"`
+	Mile   AptitudeLevel `json:"mile"`
+	Medium AptitudeLevel `json:"medium"`
+	Long   AptitudeLevel `json:"long"`
+	Front  AptitudeLevel `json:"front"`
+	Pace   AptitudeLevel `json:"pace"`
+	Late   AptitudeLevel `json:"late"`
+	End    AptitudeLevel `json:"end"`
+	Turf   AptitudeLevel `json:"turf"`
+	Dirt   AptitudeLevel `json:"dirt"`
+
+	Unique   SkillID `json:"unique"`
+	Skill1   SkillID `json:"skill1"`
+	Skill2   SkillID `json:"skill2"`
+	Skill3   SkillID `json:"skill3"`
+	SkillPL2 SkillID `json:"skill_pl2"`
+	SkillPL3 SkillID `json:"skill_pl3"`
+	SkillPL4 SkillID `json:"skill_pl4"`
+	SkillPL5 SkillID `json:"skill_pl5"`
+}
+
+type AptitudeLevel int8
+
+//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type AptitudeLevel -trimprefix AptitudeLv
+const (
+	AptitudeLvG AptitudeLevel = iota + 1
+	AptitudeLvF
+	AptitudeLvE
+	AptitudeLvD
+	AptitudeLvC
+	AptitudeLvB
+	AptitudeLvA
+	AptitudeLvS
+)

horse/uma.kk

@@ -0,0 +1,27 @@
+module horse/uma
+
+import horse/game-id
+import horse/movement
+
+// Details of an uma, or character card.
+pub struct uma-detail
+  uma-id: uma-id
+  character-id: character-id
+  sprint: aptitude-level
+  mile: aptitude-level
+  medium: aptitude-level
+  long: aptitude-level
+  front-runner: aptitude-level
+  pace-chaser: aptitude-level
+  late-surger: aptitude-level
+  end-closer: aptitude-level
+  turf: aptitude-level
+  dirt: aptitude-level
+  unique: skill-id
+  skill1: skill-id
+  skill2: skill-id
+  skill3: skill-id
+  skill-pl2: skill-id
+  skill-pl3: skill-id
+  skill-pl4: skill-id
+  skill-pl5: skill-id

horsegen/README.md

@@ -1,6 +0,0 @@
-# gen
-
-Go tool to generate the Koka source code from the game's SQLite database.
-
-Code is generated using Go templates.
-Templates use a `kkenum` function which converts a name `Mr. C.B.` to a Koka enumerant name `Mr-CB`.

horsegen/character.affinity2.sql

@@ -1,44 +0,0 @@
-WITH uma_names AS (
-	SELECT
-		"index" AS "id",
-		"text" AS "name"
-	FROM text_data
-	WHERE category = 6 AND "index" BETWEEN 1000 AND 1999
-	-- Exclude characters who have no succession relations defined.
-	AND "index" IN (SELECT chara_id FROM succession_relation_member)
-), pairs AS (
-	SELECT
-		a.id AS id_a,
-		a.name AS name_a,
-		b.id AS id_b,
-		b.name AS name_b
-	FROM uma_names a
-		JOIN uma_names b ON a.id != b.id -- exclude reflexive cases
-), relation_pairs AS (
-	SELECT
-		ra.relation_type,
-		ra.chara_id AS id_a,
-		rb.chara_id AS id_b
-	FROM succession_relation_member ra
-		JOIN succession_relation_member rb ON ra.relation_type = rb.relation_type
-), affinity AS (
-	SELECT
-		pairs.*,
-		SUM(IFNULL(relation_point, 0)) AS base_affinity
-	FROM pairs
-		LEFT JOIN relation_pairs rp ON pairs.id_a = rp.id_a AND pairs.id_b = rp.id_b
-		LEFT JOIN succession_relation sr ON rp.relation_type = sr.relation_type
-	GROUP BY pairs.id_a, pairs.id_b
-
-	UNION ALL
-	-- Reflexive cases.
-	SELECT
-		uma_names.id AS id_a,
-		uma_names.name AS name_a,
-		uma_names.id AS id_b,
-		uma_names.name AS name_b,
-		0 AS base_affinity
-	FROM uma_names
-)
-SELECT * FROM affinity
-ORDER BY id_a, id_b

horsegen/character.affinity3.sql

@@ -1,87 +0,0 @@
-WITH uma_names AS (
-	SELECT
-		"index" AS "id",
-		"text" AS "name"
-	FROM text_data
-	WHERE category = 6 AND "index" BETWEEN 1000 AND 1999
-	-- Exclude characters who have no succession relations defined.
-	AND "index" IN (SELECT chara_id FROM succession_relation_member)
-), trios AS (
-	SELECT
-		a.id AS id_a,
-		a.name AS name_a,
-		b.id AS id_b,
-		b.name AS name_b,
-		c.id AS id_c,
-		c.name AS name_c
-	FROM uma_names a
-		JOIN uma_names b ON a.id != b.id -- exclude pairwise reflexive cases
-		JOIN uma_names c ON a.id != c.id AND b.id != c.id
-), relation_trios AS (
-	SELECT
-		ra.relation_type,
-		ra.chara_id AS id_a,
-		rb.chara_id AS id_b,
-		rc.chara_id AS id_c
-	FROM succession_relation_member ra
-		JOIN succession_relation_member rb ON ra.relation_type = rb.relation_type
-		JOIN succession_relation_member rc ON ra.relation_type = rc.relation_type
-), affinity AS (
-	SELECT
-		trios.*,
-		SUM(IFNULL(relation_point, 0)) AS base_affinity
-	FROM trios
-		LEFT JOIN relation_trios rt ON trios.id_a = rt.id_a AND trios.id_b = rt.id_b AND trios.id_c = rt.id_c
-		LEFT JOIN succession_relation sr ON rt.relation_type = sr.relation_type
-	GROUP BY trios.id_a, trios.id_b, trios.id_c
-
-	UNION ALL
-	-- A = B = C
-	SELECT
-		n.id AS id_a,
-		n.name AS name_a,
-		n.id AS id_b,
-		n.name AS name_b,
-		n.id AS id_c,
-		n.name AS name_c,
-		0 AS base_affinity
-	FROM uma_names n
-
-	UNION ALL
-	-- A = B
-	SELECT
-		n.id AS id_a,
-		n.name AS name_a,
-		n.id AS id_a,
-		n.name AS id_b,
-		m.id AS id_c,
-		m.name AS name_c,
-		0 AS base_affinity
-	FROM uma_names n JOIN uma_names m ON n.id != m.id
-
-	UNION ALL
-	-- A = C
-	SELECT
-		n.id AS id_a,
-		n.name AS name_a,
-		m.id AS id_a,
-		m.name AS id_b,
-		n.id AS id_c,
-		n.name AS name_c,
-		0 AS base_affinity
-	FROM uma_names n JOIN uma_names m ON n.id != m.id
-
-	UNION ALL
-	-- B = C
-	SELECT
-		m.id AS id_a,
-		m.name AS name_a,
-		n.id AS id_a,
-		n.name AS id_b,
-		n.id AS id_c,
-		n.name AS name_c,
-		0 AS base_affinity
-	FROM uma_names n JOIN uma_names m ON n.id != m.id
-)
-SELECT * FROM affinity
-ORDER BY id_a, id_b, id_c

horsegen/character.go.template

@@ -1,72 +0,0 @@
-{{ define "go-character" -}}
-package {{ $.Region }}
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import . "git.sunturtle.xyz/zephyr/horse/horse"
-
-const (
-	{{- range $c := $.Characters }}
-	Character{{ goenum $c.Name }} CharacterID = {{ $c.ID }} // {{ $c.Name }}
-	{{- end }}
-)
-
-var OrderedCharacters = [...]CharacterID{
-	{{- range $c := $.Characters }}
-	Character{{ goenum $c.Name }},
-	{{- end }}
-}
-
-var Characters = map[CharacterID]Character{
-	{{- range $c := $.Characters }}
-	Character{{ goenum $c.Name }}: {ID: {{ $c.ID }}, Name: {{ printf "%q" $c.Name -}} },
-	{{- end }}
-}
-
-var CharacterNameToID = map[string]CharacterID{
-	{{- range $c := $.Characters }}
-	{{ printf "%q" $c.Name }}: {{ $c.ID }},
-	{{- end }}
-}
-
-var pairAffinity = []int8{
-	{{- range $a := $.Characters -}}
-		{{- range $b := $.Characters -}}
-			{{- index $.PairMaps $a.ID $b.ID -}},
-		{{- end -}}
-	{{- end -}}
-}
-
-var trioAffinity = []int8{
-	{{- range $a := $.Characters -}}
-		{{- range $b := $.Characters -}}
-			{{- range $c := $.Characters -}}
-				{{- index $.TrioMaps $a.ID $b.ID $c.ID -}},
-			{{- end -}}
-		{{- end -}}
-	{{- end -}}
-}
-
-func PairAffinity(a, b CharacterID) int {
-	if _, ok := Characters[a]; !ok {
-		return 0
-	}
-	if _, ok := Characters[b]; !ok {
-		return 0
-	}
-	return int(pairAffinity[a*{{ $.Count }} + b])
-}
-
-func TrioAffinity(a, b, c CharacterID) int {
-	if _, ok := Characters[a]; !ok {
-		return 0
-	}
-	if _, ok := Characters[b]; !ok {
-		return 0
-	}
-	if _, ok := Characters[c]; !ok {
-		return 0
-	}
-	return int(trioAffinity[a*{{ $.Count }}*{{ $.Count }} + b*{{ $.Count }} + c])
-}
-{{ end }}

horsegen/character.kk.template

@@ -1,108 +0,0 @@
-{{ define "koka-character" -}}
-module horse/{{ $.Region }}/character
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import std/core/vector
-import std/core-extras
-import std/data/rb-map
-import horse/game-id
-pub import horse/character
-
-// Enumeration of all characters for type-safe programming.
-pub type character
-  {{- range $uma := $.Characters }}
-  {{ kkenum $uma.Name }}
-  {{- end }}
-
-// Get the character ID for a character.
-pub fun character-id(c: character): character-id
-  match c
-    {{- range $uma := $.Characters }}
-    {{ kkenum $uma.Name }} -> Character-id({{ $uma.ID }})
-    {{- end }}
-
-// List of all characters in ID order for easy iterating.
-pub val all = [
-  {{- range $uma := $.Characters }}
-  {{ kkenum $uma.Name }},
-  {{- end }}
-]
-
-val name2id: rbmap<string, character-id> = rb-map/empty()
-  {{- range $uma := $.Characters }}
-  .set({{ printf "%q" $uma.Name }}, Character-id({{ $uma.ID}}))
-  {{- end }}
-
-// Get the character ID that has the given exact name.
-// If no character matches the name, the result is an invalid ID.
-pub fun from-name(name: string): character-id
-  name2id.lookup(name).default(Character-id(0))
-
-// Get the name for a character.
-// If no character matches the ID, the result is the numeric ID.
-pub fun show(c: character-id): string
-  match c.game-id
-    {{- range $uma := $.Characters }}
-    {{ $uma.ID }} -> {{ printf "%q" $uma.Name }}
-    {{- end }}
-    x -> "character " ++ x.show
-
-fun character/index(c: character-id): int
-  match c.game-id
-    {{- range $uma := $.Characters }}
-    {{ $uma.ID }} -> {{ $uma.Index }}
-    {{- end }}
-    _ -> -99999999
-
-// Create the table of all pair affinities.
-// The affinity is the value at a.index*count + b.index.
-extern global/create-pair-table(): vector<int>
-  c inline "kk_intx_t arr[] = {
-    {{- range $a := $.Characters }}
-      {{- range $b := $.Characters }}
-        {{- index $.PairMaps $a.ID $b.ID }},
-      {{- end }}
-    {{- end -}}
-  };\nkk_vector_from_cintarray(arr, (kk_ssize_t){{ $.Count }} * (kk_ssize_t){{ $.Count }}, kk_context())"
-  js inline "[
-    {{- range $a := $.Characters }}
-      {{- range $b := $.Characters }}
-        {{- index $.PairMaps $a.ID $b.ID }},
-      {{- end }}
-    {{- end -}}
-  ]"
-val global/pair-table = global/create-pair-table()
-
-// Base affinity between a pair using the global ruleset.
-pub fun global/pair-affinity(a: character-id, b: character-id): int
-  global/pair-table.at(a.index * {{ $.Count }} + b.index).default(0)
-
-// Create the table of all trio affinities.
-// The affinity is the value at a.index*count*count + b.index*count + c.index.
-extern global/create-trio-table(): vector<int>
-  c inline "kk_intx_t arr[] = {
-    {{- range $a := $.Characters }}
-      {{- range $b := $.Characters }}
-        {{- range $c := $.Characters }}
-          {{- index $.TrioMaps $a.ID $b.ID $c.ID }},
-        {{- end }}
-      {{- end }}
-    {{- end -}}
-  };\nkk_vector_from_cintarray(arr, (kk_ssize_t){{ $.Count }} * (kk_ssize_t){{ $.Count }} * (kk_ssize_t){{ $.Count }}, kk_context())"
-  js inline "[
-    {{- range $a := $.Characters }}
-      {{- range $b := $.Characters }}
-        {{- range $c := $.Characters }}
-          {{- index $.TrioMaps $a.ID $b.ID $c.ID }},
-        {{- end }}
-      {{- end }}
-    {{- end -}}
-  ]"
-val global/trio-table = global/create-trio-table()
-
-// Base affinity for a trio using the global ruleset.
-pub fun global/trio-affinity(a: character-id, b: character-id, c: character-id): int
-  global/trio-table.at(a.index * {{ $.Count }} * {{ $.Count }} + b.index * {{ $.Count }} + c.index).default(0)
-
-{{- end }}

horsegen/gen.go

@@ -1,242 +0,0 @@
-package main
-
-import (
-	"embed"
-	"errors"
-	"fmt"
-	"io"
-	"regexp"
-	"strings"
-	"text/template"
-	"unicode"
-)
-
-//go:embed *.template
-var templates embed.FS
-
-// LoadTemplates sets up templates to render game data to source code.
-func LoadTemplates() (*template.Template, error) {
-	t := template.New("root")
-	t.Funcs(template.FuncMap{
-		"kkenum": kkenum,
-		"goenum": goenum,
-	})
-	return t.ParseFS(templates, "*")
-}
-
-// ExecCharacter renders the Koka character module to kk and the Go character file to g.
-// If either is nil, it is skipped.
-func ExecCharacter(t *template.Template, region string, kk, g io.Writer, c []NamedID[Character], pairs, trios []AffinityRelation) error {
-	if len(pairs) != len(c)*len(c) {
-		return fmt.Errorf("there are %d pairs but there must be %d for %d characters", len(pairs), len(c)*len(c), len(c))
-	}
-	if len(trios) != len(c)*len(c)*len(c) {
-		return fmt.Errorf("there are %d trios but there must be %d for %d characters", len(trios), len(c)*len(c)*len(c), len(c))
-	}
-
-	maxid := 0
-	pm := make(map[int]map[int]int, len(c))
-	tm := make(map[int]map[int]map[int]int, len(c))
-	for _, u := range c {
-		maxid = max(maxid, u.ID)
-		pm[u.ID] = make(map[int]int, len(c))
-		tm[u.ID] = make(map[int]map[int]int, len(c))
-		for _, v := range c {
-			tm[u.ID][v.ID] = make(map[int]int, len(c))
-		}
-	}
-	for _, p := range pairs {
-		pm[p.IDA][p.IDB] = p.Affinity
-	}
-	for _, t := range trios {
-		tm[t.IDA][t.IDB][t.IDC] = t.Affinity
-	}
-
-	data := struct {
-		Region     string
-		Characters []NamedID[Character]
-		Pairs      []AffinityRelation
-		Trios      []AffinityRelation
-		PairMaps   map[int]map[int]int
-		TrioMaps   map[int]map[int]map[int]int
-		Count      int
-		MaxID      int
-	}{region, c, pairs, trios, pm, tm, len(c), maxid}
-	var err error
-	if kk != nil {
-		err = errors.Join(err, t.ExecuteTemplate(kk, "koka-character", &data))
-	}
-	if g != nil {
-		err = errors.Join(err, t.ExecuteTemplate(g, "go-character", &data))
-	}
-	return err
-}
-
-func ExecSkill(t *template.Template, region string, kk, g io.Writer, groups []NamedID[SkillGroup], skills []Skill) error {
-	m := make(map[int][]Skill, len(groups))
-	for _, t := range skills {
-		m[t.GroupID] = append(m[t.GroupID], t)
-	}
-	data := struct {
-		Region  string
-		Groups  []NamedID[SkillGroup]
-		Skills  []Skill
-		Related map[int][]Skill
-	}{region, groups, skills, m}
-	var err error
-	if kk != nil {
-		err = errors.Join(err, t.ExecuteTemplate(kk, "koka-skill", &data))
-	}
-	if g != nil {
-		err = errors.Join(err, t.ExecuteTemplate(g, "go-skill-data", &data))
-	}
-	return err
-}
-
-func ExecRace(t *template.Template, region string, kk, g io.Writer, races []Race) error {
-	data := struct {
-		Region string
-		Races  []Race
-	}{region, races}
-	var err error
-	if kk != nil {
-		err = errors.Join(err, t.ExecuteTemplate(kk, "koka-race", &data))
-	}
-	if g != nil {
-		err = errors.Join(err, t.ExecuteTemplate(g, "go-race", &data))
-	}
-	return err
-}
-
-func ExecSaddle(t *template.Template, region string, kk, g io.Writer, saddles []Saddle) error {
-	data := struct {
-		Region  string
-		Saddles []Saddle
-	}{region, saddles}
-	var err error
-	if kk != nil {
-		err = errors.Join(err, t.ExecuteTemplate(kk, "koka-saddle", &data))
-	}
-	if g != nil {
-		err = errors.Join(err, t.ExecuteTemplate(g, "go-saddle", &data))
-	}
-	return err
-}
-
-func ExecScenario(t *template.Template, region string, kk, g io.Writer, scen []Scenario) error {
-	data := struct {
-		Region    string
-		Scenarios []Scenario
-	}{region, scen}
-	var err error
-	if kk != nil {
-		err = errors.Join(err, t.ExecuteTemplate(kk, "koka-scenario", &data))
-	}
-	if g != nil {
-		err = errors.Join(err, t.ExecuteTemplate(g, "go-scenario", &data))
-	}
-	return err
-}
-
-func ExecSparks(t *template.Template, region string, kk, g io.Writer, sparks []Spark, effects map[int]map[int][]SparkEffect) error {
-	data := struct {
-		Region       string
-		Sparks       []Spark
-		SparkEffects map[int]map[int][]SparkEffect
-	}{region, sparks, effects}
-	var err error
-	if kk != nil {
-		err = errors.Join(err, t.ExecuteTemplate(kk, "koka-spark", &data))
-	}
-	if g != nil {
-		err = errors.Join(err, t.ExecuteTemplate(g, "go-spark", &data))
-	}
-	return err
-}
-
-const wordSeps = " ,!?/-+();#○☆♡'=♪∀ﾟ∴"
-
-var (
-	kkReplace = func() *strings.Replacer {
-		r := []string{
-			"Triple 7s", "Triple-Sevens", // hard to replace with the right thing automatically
-			"1,500,000 CC", "One-Million-CC",
-			"15,000,000 CC", "Fifteen-Million-CC",
-			"1st", "First",
-			"114th", "Hundred-Fourteenth",
-			"♡ 3D Nail Art", "Nail-Art",
-			".", "",
-			"\u2019", "",
-			"&", "-and-",
-			"'s", "s",
-			"ó", "o",
-			"∞", "Infinity",
-			"\u00d7", "x",
-			"◎", "Lv2",
-		}
-		for _, c := range wordSeps {
-			r = append(r, string(c), "-")
-		}
-		return strings.NewReplacer(r...)
-	}()
-	kkMultidash     = regexp.MustCompile(`-+`)
-	kkDashNonletter = regexp.MustCompile(`-[^A-Za-z]`)
-
-	goReplace = func() *strings.Replacer {
-		r := []string{
-			"Triple 7s", "TripleSevens",
-			"1,500,000 CC", "OneMillionCC",
-			"15,000,000 CC", "FifteenMillionCC",
-			"1st", "First",
-			"♡ 3D Nail Art", "NailArt",
-			".", "",
-			"\u2019", "",
-			"&", "And",
-			"'s", "s",
-			"∞", "Infinity",
-			"\u00d7", "X",
-			"◎", "Lv2",
-		}
-		for _, c := range wordSeps {
-			r = append(r, string(c), "")
-		}
-		return strings.NewReplacer(r...)
-	}()
-)
-
-func kkenum(name string) string {
-	orig := name
-	name = kkReplace.Replace(name)
-	name = kkMultidash.ReplaceAllLiteralString(name, "-")
-	name = strings.Trim(name, "-")
-	if len(name) == 0 {
-		panic(fmt.Errorf("%q became empty as Koka enum variant", orig))
-	}
-	name = strings.ToUpper(name[:1]) + name[1:]
-	if !unicode.IsLetter(rune(name[0])) {
-		//lint:ignore ST1005 proper name
-		panic(fmt.Errorf("Koka enum variant %q (from %q) starts with a non-letter", name, orig))
-	}
-	for _, c := range name {
-		if c > 127 {
-			// Koka does not allow non-ASCII characters in source code.
-			// Don't proceed if we've missed one.
-			panic(fmt.Errorf("non-ASCII character %q (%[1]U) in Koka enum variant %q (from %q)", c, name, orig))
-		}
-	}
-	if kkDashNonletter.MatchString(name) {
-		panic(fmt.Errorf("non-letter character after a dash in Koka enum variant %q (from %q)", name, orig))
-	}
-	return name
-}
-
-func goenum(name string) string {
-	// go names are a bit more lax, so we need fewer checks
-	orig := name
-	name = goReplace.Replace(name)
-	if len(name) == 0 {
-		panic(fmt.Errorf("%q became empty as Go enum variant", orig))
-	}
-	name = strings.ToUpper(name[:1]) + name[1:]
-	return name
-}

horsegen/load.go

@@ -1,540 +0,0 @@
-package main
-
-import (
-	"context"
-	_ "embed"
-	"fmt"
-
-	"zombiezen.com/go/sqlite/sqlitex"
-)
-
-//go:embed character.sql
-var characterSQL string
-
-//go:embed character.affinity2.sql
-var characterAffinity2SQL string
-
-//go:embed character.affinity3.sql
-var characterAffinity3SQL string
-
-//go:embed skill-group.sql
-var skillGroupSQL string
-
-//go:embed skill.sql
-var skillSQL string
-
-//go:embed race.sql
-var raceSQL string
-
-//go:embed saddle.sql
-var saddleSQL string
-
-//go:embed scenario.sql
-var scenarioSQL string
-
-//go:embed spark.sql
-var sparkSQL string
-
-//go:embed spark-effect.sql
-var sparkEffectSQL string
-
-type (
-	Character  struct{}
-	SkillGroup struct{}
-)
-
-type NamedID[T any] struct {
-	// Disallow conversions between NamedID types.
-	_ [0]*T
-
-	ID   int
-	Name string
-	// For internal use, the index of the identity, when it's needed.
-	// We don't show this in public API, but it lets us use vectors for lookups.
-	Index int
-}
-
-func Characters(ctx context.Context, db *sqlitex.Pool) ([]NamedID[Character], error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for characters: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(characterSQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for characters: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []NamedID[Character]
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping characters: %w", err)
-		}
-		if !ok {
-			break
-		}
-		c := NamedID[Character]{
-			ID:    stmt.ColumnInt(0),
-			Name:  stmt.ColumnText(1),
-			Index: stmt.ColumnInt(2),
-		}
-		r = append(r, c)
-	}
-	return r, nil
-}
-
-type AffinityRelation struct {
-	IDA      int
-	NameA    string
-	IDB      int
-	NameB    string
-	IDC      int
-	NameC    string
-	Affinity int
-}
-
-func CharacterPairs(ctx context.Context, db *sqlitex.Pool) ([]AffinityRelation, error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for character pairs: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(characterAffinity2SQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for character pairs: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []AffinityRelation
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping character pairs: %w", err)
-		}
-		if !ok {
-			break
-		}
-		p := AffinityRelation{
-			IDA:      stmt.ColumnInt(0),
-			NameA:    stmt.ColumnText(1),
-			IDB:      stmt.ColumnInt(2),
-			NameB:    stmt.ColumnText(3),
-			Affinity: stmt.ColumnInt(4),
-		}
-		r = append(r, p)
-	}
-	return r, nil
-}
-
-func CharacterTrios(ctx context.Context, db *sqlitex.Pool) ([]AffinityRelation, error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for character trios: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(characterAffinity3SQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for character trios: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []AffinityRelation
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping character trios: %w", err)
-		}
-		if !ok {
-			break
-		}
-		p := AffinityRelation{
-			IDA:      stmt.ColumnInt(0),
-			NameA:    stmt.ColumnText(1),
-			IDB:      stmt.ColumnInt(2),
-			NameB:    stmt.ColumnText(3),
-			IDC:      stmt.ColumnInt(4),
-			NameC:    stmt.ColumnText(5),
-			Affinity: stmt.ColumnInt(6),
-		}
-		r = append(r, p)
-	}
-	return r, nil
-}
-
-func SkillGroups(ctx context.Context, db *sqlitex.Pool) ([]NamedID[SkillGroup], error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for skill groups: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(skillGroupSQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for skill groups: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []NamedID[SkillGroup]
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping skill groups: %w", err)
-		}
-		if !ok {
-			break
-		}
-		g := NamedID[SkillGroup]{
-			ID:   stmt.ColumnInt(0),
-			Name: stmt.ColumnText(1),
-		}
-		r = append(r, g)
-	}
-	return r, nil
-}
-
-type Skill struct {
-	ID            int
-	Name          string
-	Description   string
-	GroupID       int
-	GroupName     string
-	Rarity        int
-	GroupRate     int
-	GradeValue    int
-	WitCheck      bool
-	Activations   [2]SkillActivation
-	SPCost        int
-	InheritID     int
-	UniqueOwnerID int
-	UniqueOwner   string
-	IconID        int
-	Index         int
-}
-
-type SkillActivation struct {
-	Precondition string
-	Condition    string
-	Duration     int
-	Cooldown     int
-	Abilities    [3]SkillAbility
-}
-
-type SkillAbility struct {
-	Type        int
-	ValueUsage  int
-	Value       int
-	Target      int
-	TargetValue int
-}
-
-func Skills(ctx context.Context, db *sqlitex.Pool) ([]Skill, error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for skills: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(skillSQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for skills: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []Skill
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping skills: %w", err)
-		}
-		if !ok {
-			break
-		}
-		s := Skill{
-			ID:          stmt.ColumnInt(0),
-			Name:        stmt.ColumnText(1),
-			Description: stmt.ColumnText(2),
-			GroupID:     stmt.ColumnInt(3),
-			GroupName:   stmt.ColumnText(4),
-			Rarity:      stmt.ColumnInt(5),
-			GroupRate:   stmt.ColumnInt(6),
-			GradeValue:  stmt.ColumnInt(7),
-			WitCheck:    stmt.ColumnInt(8) != 0,
-			Activations: [2]SkillActivation{
-				{
-					Precondition: stmt.ColumnText(9),
-					Condition:    stmt.ColumnText(10),
-					Duration:     stmt.ColumnInt(11),
-					Cooldown:     stmt.ColumnInt(12),
-					Abilities: [3]SkillAbility{
-						{
-							Type:        stmt.ColumnInt(13),
-							ValueUsage:  stmt.ColumnInt(14),
-							Value:       stmt.ColumnInt(15),
-							Target:      stmt.ColumnInt(16),
-							TargetValue: stmt.ColumnInt(17),
-						},
-						{
-							Type:        stmt.ColumnInt(18),
-							ValueUsage:  stmt.ColumnInt(19),
-							Value:       stmt.ColumnInt(20),
-							Target:      stmt.ColumnInt(21),
-							TargetValue: stmt.ColumnInt(22),
-						},
-						{
-							Type:        stmt.ColumnInt(23),
-							ValueUsage:  stmt.ColumnInt(24),
-							Value:       stmt.ColumnInt(25),
-							Target:      stmt.ColumnInt(26),
-							TargetValue: stmt.ColumnInt(27),
-						},
-					},
-				},
-				{
-					Precondition: stmt.ColumnText(28),
-					Condition:    stmt.ColumnText(29),
-					Duration:     stmt.ColumnInt(30),
-					Cooldown:     stmt.ColumnInt(31),
-					Abilities: [3]SkillAbility{
-						{
-							Type:        stmt.ColumnInt(32),
-							ValueUsage:  stmt.ColumnInt(33),
-							Value:       stmt.ColumnInt(34),
-							Target:      stmt.ColumnInt(35),
-							TargetValue: stmt.ColumnInt(36),
-						},
-						{
-							Type:        stmt.ColumnInt(37),
-							ValueUsage:  stmt.ColumnInt(38),
-							Value:       stmt.ColumnInt(39),
-							Target:      stmt.ColumnInt(40),
-							TargetValue: stmt.ColumnInt(41),
-						},
-						{
-							Type:        stmt.ColumnInt(42),
-							ValueUsage:  stmt.ColumnInt(43),
-							Value:       stmt.ColumnInt(44),
-							Target:      stmt.ColumnInt(45),
-							TargetValue: stmt.ColumnInt(46),
-						},
-					},
-				},
-			},
-			SPCost:        stmt.ColumnInt(47),
-			InheritID:     stmt.ColumnInt(48),
-			UniqueOwnerID: stmt.ColumnInt(49),
-			UniqueOwner:   stmt.ColumnText(50),
-			IconID:        stmt.ColumnInt(51),
-			Index:         stmt.ColumnInt(52),
-		}
-		r = append(r, s)
-	}
-	return r, nil
-}
-
-type Race struct {
-	ID          int
-	Name        string
-	Grade       int
-	ThumbnailID int
-	Primary     int
-	Alternate   int
-}
-
-func Races(ctx context.Context, db *sqlitex.Pool) ([]Race, error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for races: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(raceSQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for races: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []Race
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping races: %w", err)
-		}
-		if !ok {
-			break
-		}
-		race := Race{
-			ID:          stmt.ColumnInt(0),
-			Name:        stmt.ColumnText(1),
-			Grade:       stmt.ColumnInt(2),
-			ThumbnailID: stmt.ColumnInt(3),
-			Primary:     stmt.ColumnInt(4),
-			Alternate:   stmt.ColumnInt(5),
-		}
-		r = append(r, race)
-	}
-	return r, nil
-}
-
-type Saddle struct {
-	ID        int
-	Name      string
-	Races     [3]int
-	Type      int
-	Primary   int
-	Alternate int
-}
-
-func Saddles(ctx context.Context, db *sqlitex.Pool) ([]Saddle, error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for saddles: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(saddleSQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for saddles: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []Saddle
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping saddles: %w", err)
-		}
-		if !ok {
-			break
-		}
-		s := Saddle{
-			ID:        stmt.ColumnInt(0),
-			Name:      stmt.ColumnText(1),
-			Races:     [3]int{stmt.ColumnInt(2), stmt.ColumnInt(3), stmt.ColumnInt(4)},
-			Type:      stmt.ColumnInt(5),
-			Primary:   stmt.ColumnInt(6),
-			Alternate: stmt.ColumnInt(7),
-		}
-		r = append(r, s)
-	}
-	return r, nil
-}
-
-type Scenario struct {
-	ID    int
-	Name  string
-	Title string
-}
-
-func Scenarios(ctx context.Context, db *sqlitex.Pool) ([]Scenario, error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for scenario: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(scenarioSQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for scenario: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []Scenario
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping scenarios: %w", err)
-		}
-		if !ok {
-			break
-		}
-		s := Scenario{
-			ID:    stmt.ColumnInt(0),
-			Name:  stmt.ColumnText(1),
-			Title: stmt.ColumnText(2),
-		}
-		r = append(r, s)
-	}
-	return r, nil
-}
-
-type Spark struct {
-	ID          int
-	Name        string
-	Description string
-	Group       int
-	Rarity      int
-	Type        int
-}
-
-type SparkEffect struct {
-	Target int
-	Value1 int
-	Value2 int
-}
-
-func Sparks(ctx context.Context, db *sqlitex.Pool) ([]Spark, error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for sparks: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(sparkSQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for sparks: %w", err)
-	}
-	defer stmt.Finalize()
-
-	var r []Spark
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping sparks: %w", err)
-		}
-		if !ok {
-			break
-		}
-		s := Spark{
-			ID:          stmt.ColumnInt(0),
-			Name:        stmt.ColumnText(1),
-			Description: stmt.ColumnText(2),
-			Group:       stmt.ColumnInt(3),
-			Rarity:      stmt.ColumnInt(4),
-			Type:        stmt.ColumnInt(5),
-		}
-		r = append(r, s)
-	}
-	return r, nil
-}
-
-func SparkEffects(ctx context.Context, db *sqlitex.Pool) (map[int]map[int][]SparkEffect, error) {
-	conn, err := db.Take(ctx)
-	defer db.Put(conn)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't get connection for spark effects: %w", err)
-	}
-	stmt, _, err := conn.PrepareTransient(sparkEffectSQL)
-	if err != nil {
-		return nil, fmt.Errorf("couldn't prepare statement for spark effects: %w", err)
-	}
-	defer stmt.Finalize()
-
-	r := make(map[int]map[int][]SparkEffect)
-	for {
-		ok, err := stmt.Step()
-		if err != nil {
-			return nil, fmt.Errorf("error stepping spark effects: %w", err)
-		}
-		if !ok {
-			break
-		}
-		group := stmt.ColumnInt(0)
-		eff := stmt.ColumnInt(1)
-		s := SparkEffect{
-			Target: stmt.ColumnInt(2),
-			Value1: stmt.ColumnInt(3),
-			Value2: stmt.ColumnInt(4),
-		}
-		if r[group] == nil {
-			r[group] = make(map[int][]SparkEffect)
-		}
-		r[group][eff] = append(r[group][eff], s)
-	}
-	return r, nil
-}

horsegen/main.go

@@ -1,208 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"log/slog"
-	"os"
-	"os/signal"
-	"path/filepath"
-
-	"golang.org/x/sync/errgroup"
-	"zombiezen.com/go/sqlite"
-	"zombiezen.com/go/sqlite/sqlitex"
-)
-
-func main() {
-	var (
-		mdb    string
-		out    string
-		region string
-	)
-	flag.StringVar(&mdb, "mdb", os.ExpandEnv(`$USERPROFILE\AppData\LocalLow\Cygames\Umamusume\master\master.mdb`), "`path` to Umamusume master.mdb")
-	flag.StringVar(&out, "o", `horse`, "`dir`ectory for output files")
-	flag.StringVar(&region, "region", "global", "region the database is for (global, jp)")
-	flag.Parse()
-
-	pctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
-	go func() {
-		<-pctx.Done()
-		stop()
-	}()
-
-	t, err := LoadTemplates()
-	if err != nil {
-		slog.Error("loading templates", slog.Any("err", err))
-		os.Exit(2)
-	}
-
-	slog.Info("open", slog.String("mdb", mdb))
-	db, err := sqlitex.NewPool(mdb, sqlitex.PoolOptions{Flags: sqlite.OpenReadOnly})
-	if err != nil {
-		slog.Error("opening mdb", slog.String("mdb", mdb), slog.Any("err", err))
-		os.Exit(1)
-	}
-
-	eg, ctx := errgroup.WithContext(pctx)
-	var (
-		charas   []NamedID[Character]
-		pairs    []AffinityRelation
-		trios    []AffinityRelation
-		sg       []NamedID[SkillGroup]
-		skills   []Skill
-		races    []Race
-		saddles  []Saddle
-		scens    []Scenario
-		sparks   []Spark
-		sparkeff map[int]map[int][]SparkEffect
-	)
-	eg.Go(func() error {
-		slog.Info("get characters")
-		r, err := Characters(ctx, db)
-		charas = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get pairs")
-		r, err := CharacterPairs(ctx, db)
-		pairs = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get trios")
-		r, err := CharacterTrios(ctx, db)
-		trios = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get skill groups")
-		r, err := SkillGroups(ctx, db)
-		sg = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get skills")
-		r, err := Skills(ctx, db)
-		skills = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get races")
-		r, err := Races(ctx, db)
-		races = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get saddles")
-		r, err := Saddles(ctx, db)
-		saddles = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get scenarios")
-		r, err := Scenarios(ctx, db)
-		scens = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get sparks")
-		r, err := Sparks(ctx, db)
-		sparks = r
-		return err
-	})
-	eg.Go(func() error {
-		slog.Info("get spark effects")
-		r, err := SparkEffects(ctx, db)
-		sparkeff = r
-		return err
-	})
-	if err := eg.Wait(); err != nil {
-		slog.Error("load", slog.Any("err", err))
-		os.Exit(1)
-	}
-
-	if err := os.MkdirAll(filepath.Join(out, region), 0775); err != nil {
-		slog.Error("create output dir", slog.Any("err", err))
-		os.Exit(1)
-	}
-
-	eg, ctx = errgroup.WithContext(pctx)
-	eg.Go(func() error {
-		cf, err := os.Create(filepath.Join(out, region, "character.kk"))
-		if err != nil {
-			return err
-		}
-		gf, err := os.Create(filepath.Join(out, region, "character.go"))
-		if err != nil {
-			return err
-		}
-		slog.Info("write characters")
-		return ExecCharacter(t, region, cf, gf, charas, pairs, trios)
-	})
-	eg.Go(func() error {
-		sf, err := os.Create(filepath.Join(out, region, "skill.kk"))
-		if err != nil {
-			return err
-		}
-		gf, err := os.Create(filepath.Join(out, region, "skill.go"))
-		if err != nil {
-			return err
-		}
-		slog.Info("write skills")
-		return ExecSkill(t, region, sf, gf, sg, skills)
-	})
-	eg.Go(func() error {
-		kf, err := os.Create(filepath.Join(out, region, "race.kk"))
-		if err != nil {
-			return err
-		}
-		gf, err := os.Create(filepath.Join(out, region, "race.go"))
-		if err != nil {
-			return err
-		}
-		slog.Info("write races")
-		return ExecRace(t, region, kf, gf, races)
-	})
-	eg.Go(func() error {
-		kf, err := os.Create(filepath.Join(out, region, "saddle.kk"))
-		if err != nil {
-			return err
-		}
-		gf, err := os.Create(filepath.Join(out, region, "saddle.go"))
-		if err != nil {
-			return err
-		}
-		slog.Info("write saddles")
-		return ExecSaddle(t, region, kf, gf, saddles)
-	})
-	eg.Go(func() error {
-		kf, err := os.Create(filepath.Join(out, region, "scenario.kk"))
-		if err != nil {
-			return err
-		}
-		gf, err := os.Create(filepath.Join(out, region, "scenario.go"))
-		if err != nil {
-			return err
-		}
-		slog.Info("write scenarios")
-		return ExecScenario(t, region, kf, gf, scens)
-	})
-	eg.Go(func() error {
-		kf, err := os.Create(filepath.Join(out, region, "spark.kk"))
-		if err != nil {
-			return err
-		}
-		gf, err := os.Create(filepath.Join(out, region, "spark.go"))
-		if err != nil {
-			return err
-		}
-		slog.Info("write sparks")
-		return ExecSparks(t, region, kf, gf, sparks, sparkeff)
-	})
-	if err := eg.Wait(); err != nil {
-		slog.Error("generate", slog.Any("err", err))
-		os.Exit(1)
-	} else {
-		slog.Info("done")
-	}
-}

horsegen/race.go.template

@@ -1,32 +0,0 @@
-{{- define "go-race" -}}
-package {{ $.Region }}
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import . "git.sunturtle.xyz/zephyr/horse/horse"
-
-const (
-	{{- range $r := $.Races }}
-	Race{{ goenum $r.Name }}{{ if $r.Alternate }}Alt{{ $r.ID }}{{ end }} RaceID = {{ $r.ID }} // {{ $r.Name }}
-	{{- end }}
-)
-
-var AllRaces = map[RaceID]Race{
-	{{- range $r := $.Races }}
-	Race{{ goenum $r.Name }}{{ if $r.Alternate }}Alt{{ $r.ID }}{{ end }}: {
-		ID: {{ $r.ID }},
-		Name: {{ printf "%q" $r.Name }}{{ if $r.Alternate }} + " (Alternate {{ $r.ID }})"{{ end }},
-		Thumbnail: {{ $r.ThumbnailID }},
-		{{- if ne $r.Primary $r.ID }}
-		Primary: {{ $r.Primary }},
-		{{- end }}
-	},
-	{{- end }}
-}
-
-var RaceNameToID = map[string]RaceID{
-	{{- range $r := $.Races }}
-	{{ printf "%q" $r.Name }}{{ if $r.Alternate }} + " (Alternate {{ $r.ID }})"{{ end }}: {{ $r.ID }},
-	{{- end }}
-}
-{{ end }}

horsegen/race.kk.template

@@ -1,80 +0,0 @@
-{{- define "koka-race" -}}
-module horse/{{ $.Region }}/race
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import std/data/rb-map
-import horse/game-id
-pub import horse/race
-
-// Enumeration of all races for type-safe programming.
-pub type race
-  {{- range $r := $.Races }}
-  {{ kkenum $r.Name }}{{ if $r.Alternate }}-Alt{{ $r.ID }}{{ end }}
-  {{- end }}
-
-// Get the race ID for a race.
-pub fun race-id(r: race): race-id
-  match r
-    {{- range $r := $.Races }}
-    {{ kkenum $r.Name }}{{ if $r.Alternate }}-Alt{{ $r.ID }}{{ end }} -> Race-id({{ $r.ID }})
-    {{- end }}
-
-// List of all races in ID order for easy iterating.
-pub val all = [
-  {{- range $r := $.Races }}
-  {{ kkenum $r.Name }}{{ if $r.Alternate }}-Alt{{ $r.ID }}{{ end }},
-  {{- end }}
-]
-
-val name2id: rbmap<string, race-id> = rb-map/empty()
-  {{- range $r := $.Races }}
-  .set({{ printf "%q" $r.Name }}{{ if $r.Alternate }} ++ " (Alternate {{ $r.ID }})"{{ end }}, Race-id({{ $r.ID }}))
-  {{- end }}
-
-// Get the race ID that has the given exact name.
-// Alternate versions of races have an indication of their ID in their names.
-// If no race matches the name, the result is an invalid ID.
-pub fun from-name(name: string): race-id
-  name2id.lookup(name).default(Race-id(0))
-
-// Get the name for a race.
-// Alternate versions of races have an indication of their ID in their names.
-// If no race matches the ID, the result is the numeric ID.
-pub fun show(r: race-id): string
-  match r.game-id
-    {{- range $r := $.Races }}
-    {{ $r.ID }} -> {{ printf "%q" $r.Name }}{{ if $r.Alternate }} ++ " (Alternate {{ $r.ID }})"{{ end }}
-    {{- end }}
-    x -> "race " ++ x.show
-
-// Get the grade for a race.
-// If no race matches the ID, the result is Pre-OP.
-pub fun grade(r: race-id): grade
-  match r.game-id
-    {{- range $r := $.Races }}
-    {{ $r.ID }} -> {{ if eq $r.Grade 100 }}G1{{ else if eq $r.Grade 200 }}G2{{ else if eq $r.Grade 300 }}G3{{ else if eq $r.Grade 400 }}OP{{ else if eq $r.Grade 700 }}Pre-OP{{ else }}??? $r.Grade={{ $r.Grade }}{{ end }}
-    {{- end }}
-    _ -> Pre-OP
-
-// Get the thumbnail ID for a race.
-// If no race matches the ID, the result is an invalid ID.
-pub fun thumbnail(r: race-id): race-thumbnail-id
-  match r.game-id
-    {{- range $r := $.Races }}
-    {{ $r.ID }} -> Race-thumbnail-id({{ $r.ThumbnailID }})
-    {{- end }}
-    _ -> Race-thumbnail-id(0)
-
-// Get the primary ID for a race.
-// For races which are the primary version, or if no race matches the given ID,
-// the result is the input.
-pub fun primary(r: race-id): race-id
-  match r.game-id
-    {{- range $r := $.Races }}
-    {{- if $r.Alternate }}
-    {{ $r.ID }} -> Race-id({{ $r.Primary }})
-    {{- end }}
-    {{- end }}
-    _ -> r
-{{ end }}

horsegen/saddle.go.template

@@ -1,27 +0,0 @@
-{{- define "go-saddle" -}}
-package {{ $.Region }}
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import . "git.sunturtle.xyz/zephyr/horse/horse"
-
-const (
-	{{- range $s := $.Saddles }}
-	Saddle{{ goenum $s.Name }}{{ if $s.Alternate }}Alt{{ $s.Alternate }}{{ end }} SaddleID = {{ $s.ID }} // {{ $s.Name }}
-	{{- end }}
-)
-
-var AllSaddles = map[SaddleID]Saddle{
-	{{- range $s := $.Saddles }}
-	Saddle{{ goenum $s.Name }}{{ if $s.Alternate }}Alt{{ $s.Alternate }}{{ end }}: {
-		ID: {{ $s.ID }},
-		Name: {{ printf "%q" $s.Name }}{{ if $s.Alternate }} + " (Alternate {{ $s.Alternate }})"{{ end }},
-		Races: []RaceID{ {{- range $id := $s.Races }}{{ if $id }}{{ $id }}, {{ end }}{{ end -}} },
-		Type: SaddleType{{ if eq $s.Type 0 }}Honor{{ else if eq $s.Type 1 }}G3{{ else if eq $s.Type 2 }}G2{{ else if eq $s.Type 3 }}G1{{ else }}??? $s.Type={{ $s.Type }}{{ end }},
-		{{- if $s.Alternate }}
-		Primary: {{ $s.Primary }},
-		{{- end }}
-	},
-	{{- end }}
-}
-{{ end }}

horsegen/saddle.kk.template

@@ -1,69 +0,0 @@
-{{- define "koka-saddle" -}}
-module horse/{{ $.Region }}/saddle
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import horse/game-id
-pub import horse/race
-pub import horse/{{ $.Region }}/race
-
-// Enumeration of all saddles for type-safe programming.
-pub type saddle
-  {{- range $s := $.Saddles }}
-  {{ kkenum $s.Name }}{{ if $s.Alternate }}-Alt{{ $s.ID }}{{ end }}
-  {{- end }}
-
-// Get the saddle ID for a saddle.
-pub fun saddle-id(s: saddle): saddle-id
-  match s
-    {{- range $s := $.Saddles }}
-    {{ kkenum $s.Name }}{{ if $s.Alternate }}-Alt{{ $s.ID }}{{ end }} -> Saddle-id({{ $s.ID }})
-    {{- end }}
-  
-// List of all saddles in ID order for easy iterating.
-pub val all = [
-  {{- range $s := $.Saddles }}
-  {{ kkenum $s.Name }}{{ if $s.Alternate }}-Alt{{ $s.ID }}{{ end }},
-  {{- end }}
-]
-
-// Get the name for a saddle.
-// Alternate versions of saddles have an indication of their ID in their names.
-// If no saddle matches the ID, the result contains the numeric ID.
-pub fun show(s: saddle-id): string
-  match s.game-id
-    {{- range $s := $.Saddles }}
-    {{ $s.ID }} -> {{ printf "%q" $s.Name }}{{ if $s.Alternate }} ++ " (Alternate {{ $s.ID }})"{{ end }}
-    {{- end }}
-    x -> "saddle " ++ x.show
-
-// Get the list of races that entitle a horse to a saddle.
-// If no saddle matches the ID, the result is the empty list.
-pub fun races(s: saddle-id): list<race-id>
-  match s.game-id
-    {{- range $s := $.Saddles }}
-    {{ $s.ID }} -> [{{ range $id := $s.Races }}{{ if $id }}Race-id({{ $id }}), {{ end }}{{ end }}]
-    {{- end }}
-    _ -> []
-
-// Get a saddle's type.
-// If no saddle matches the ID, the result is Honor.
-pub fun saddle-type(s: saddle-id): saddle-type
-  match s.game-id
-    {{- range $s := $.Saddles }}
-    {{ $s.ID }} -> {{ if eq $s.Type 0 }}Honor{{ else if eq $s.Type 1 }}G3-Win{{ else if eq $s.Type 2 }}G2-Win{{ else if eq $s.Type 3 }}G1-Win{{ else }}??? $s.Type={{ $s.Type }}{{ end }}
-    {{- end }}
-    _ -> Honor
-
-// Get the primary ID for a saddle.
-// For saddles which are the primary version, or if no saddle matches the given ID,
-// the result is the input.
-pub fun primary(s: saddle-id): saddle-id
-  match s.game-id
-    {{- range $s := $.Saddles }}
-    {{- if $s.Alternate }}
-    {{ $s.ID }} -> Saddle-id({{ $s.Primary }})
-    {{- end }}
-    {{- end }}
-    _ -> s
-{{ end }}

horsegen/scenario.go.template

@@ -1,23 +0,0 @@
-{{- define "go-scenario" -}}
-package {{ $.Region }}
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import . "git.sunturtle.xyz/zephyr/horse/horse"
-
-const (
-	{{- range $s := $.Scenarios }}
-	Scenario{{ goenum $s.Name }} ScenarioID = {{ $s.ID }} // {{ $s.Name }}
-	{{- end }}
-)
-
-var AllScenarios = map[ScenarioID]Scenario{
-	{{- range $s := $.Scenarios }}
-	Scenario{{ goenum $s.Name }}: {
-		ID: {{ $s.ID }},
-		Name: {{ printf "%q" $s.Name }},
-		Title: {{ printf "%q" $s.Title }},
-	},
-	{{- end }}
-}
-{{ end }}

horsegen/scenario.kk.template

@@ -1,45 +0,0 @@
-{{- define "koka-scenario" -}}
-module horse/{{ $.Region }}/scenario
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import horse/game-id
-
-// Enumeration of all scenarios for type-safe programming.
-pub type scenario
-  {{- range $s := $.Scenarios }}
-  {{ kkenum $s.Name }}
-  {{- end }}
-
-// Get the scenario ID for a scenario.
-pub fun scenario-id(s: scenario): scenario-id
-  match s
-    {{- range $s := $.Scenarios }}
-    {{ kkenum $s.Name }} -> Scenario-id({{ $s.ID }})
-    {{- end }}
-  
-// List of all scenarios in ID order for easy iterating.
-pub val all = [
-  {{- range $s := $.Scenarios }}
-  {{ kkenum $s.Name }},
-  {{- end }}
-]
-
-// Get the name for a scenario.
-// If no scenario matches the ID, the result contains the numeric ID.
-pub fun show(s: scenario-id): string
-  match s.game-id
-    {{- range $s := $.Scenarios }}
-    {{ $s.ID }} -> {{ printf "%q" $s.Name }}
-    {{- end }}
-    x -> "scenario " ++ x.show
-
-// Get the full title for a scenario, e.g. "The Beginning: URA Finale".
-// If no scenario matches the ID, the result contains the numeric ID.
-pub fun title(s: scenario-id): string
-  match s.game-id
-    {{- range $s := $.Scenarios }}
-    {{ $s.ID }} -> {{ printf "%q" $s.Title }}
-    {{- end }}
-    x -> "scenario " ++ x.show
-{{ end }}

horsegen/skill-group.sql

@@ -1,14 +0,0 @@
-WITH skill_names AS (
-	SELECT
-		"index" AS "id",
-		"text" AS "name"
-	FROM text_data
-	WHERE category = 47
-)
-SELECT
-	group_id,
-	name
-FROM skill_data d
-	JOIN skill_names n ON d.id = n.id
-WHERE d.group_rate = 1
-ORDER BY group_id

horsegen/skill.go.template

@@ -1,78 +0,0 @@
-{{- define "go-skill-data" -}}
-package {{ $.Region }}
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import . "git.sunturtle.xyz/zephyr/horse/horse"
-
-const (
-	{{- range $s := $.Skills }}
-	Skill{{ goenum $s.Name }}{{ if ne $s.InheritID 0 }}Inherit{{ end }} SkillID = {{ $s.ID }} // {{ $s.Name }}
-	{{- end }}
-)
-
-var OrderedSkills = [...]SkillID{
-	{{- range $s := $.Skills }}
-	Skill{{ goenum $s.Name }}{{ if ne $s.InheritID 0 }}Inherit{{ end }},
-	{{- end }}
-}
-
-var AllSkills = map[SkillID]Skill{
-	{{- range $s := $.Skills }}
-	Skill{{ goenum $s.Name }}{{ if ne $s.InheritID 0 }}Inherit{{ end }}: {
-		ID: {{ $s.ID }},
-		Name: {{ printf "%q" $s.Name }}{{ if ne $s.InheritID 0 }} + " (Inherited)"{{ end }},
-		Description: {{ printf "%q" $s.Description }},
-		Group: {{ $s.GroupID }},
-		Rarity: {{ $s.Rarity }},
-		GroupRate: {{ $s.GroupRate }},
-		GradeValue: {{ $s.GradeValue }},
-		{{- if $s.WitCheck }}
-		WitCheck: {{ $s.WitCheck }},
-		{{- end }}
-		Activations: []Activation{
-			{{- range $a := $s.Activations }}
-			{{- if ne $a.Condition "" }}
-			{
-				{{- if $a.Precondition }}
-				Precondition: {{ printf "%q" $a.Precondition }},
-				{{- end }}
-				Condition: {{ printf "%q" $a.Condition }},
-				Duration: {{ $a.Duration }},
-				{{- if $a.Cooldown }}
-				Cooldown: {{ $a.Cooldown }},
-				{{- end }}
-				Abilities: []Ability{
-					{{- range $abil := $a.Abilities }}
-					{{- if ne $abil.Type 0 }}
-					{Type: {{ $abil.Type }}, ValueUsage: {{ $abil.ValueUsage }}, Value: {{ $abil.Value }}, Target: {{ $abil.Target }}, TargetValue: {{ $abil.TargetValue -}} },
-					{{- end }}
-					{{- end }}
-				},
-			},
-			{{- end }}
-			{{- end }}
-		},
-		{{- if $s.UniqueOwner }}
-		UniqueOwner: {{ printf "%q" $s.UniqueOwner }},
-		{{- end }}
-		{{- if $s.SPCost }}
-		SPCost: {{ $s.SPCost }},
-		{{- end }}
-		IconID: {{ $s.IconID }},
-	},
-	{{- end }}
-}
-
-var SkillNameToID = map[string]SkillID{
-	{{- range $s := $.Skills }}
-	{{ printf "%q" $s.Name }}{{ if ne $s.InheritID 0 }} + " (Inherited)"{{ end }}: {{ $s.ID }},
-	{{- end }}
-}
-
-var SkillGroups = map[int32][4]SkillID{
-	{{- range $g := $.Groups }}
-	{{ $g.ID }}: { {{- range $s := index $.Related $g.ID }}Skill{{ goenum $s.Name }}{{ if ne $s.InheritID 0 }}Inherit{{ end }}, {{ end -}} },
-	{{- end }}
-}
-{{ end }}

horsegen/skill.kk.template

@@ -1,233 +0,0 @@
-{{- define "koka-skill" -}}
-module horse/{{ $.Region }}/skill
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import std/data/rb-map
-import std/num/decimal
-import horse/game-id
-import horse/movement
-pub import horse/skill
-
-// Enumeration of all skills for type-safe programming.
-pub type skill
-  {{- range $s := $.Skills }}
-  {{ kkenum $s.Name }}{{ if $s.InheritID }}-Inherit{{ end }}
-  {{- end }}
-
-// Get the skill ID for a skill.
-pub fun skill-id(s: skill): skill-id
-  match s
-    {{- range $s := $.Skills }}
-    {{ kkenum $s.Name }}{{ if $s.InheritID }}-Inherit{{ end }} -> Skill-id({{ $s.ID }})
-    {{- end }}
-
-// List of all skills in ID order for easy iterating.
-pub val all = [
-  {{- range $s := $.Skills }}
-  {{ kkenum $s.Name }}{{ if $s.InheritID }}-Inherit{{ end }},
-  {{- end }}
-]
-
-val name2id: rbmap<string, skill-id> = rb-map/empty()
-  {{- range $s := $.Skills }}
-  .set({{ printf "%q" $s.Name }}{{ if $s.InheritID }} ++ " (Inherited)"{{ end }}, Skill-id({{ $s.ID }}))
-  {{- end }}
-
-// Get the skill ID that has the given exact name.
-// Inherited skills have `" (Inherited)"` appended to their names.
-// If no skill matches the name, the result is an invalid ID.
-pub fun from-name(name: string): skill-id
-  name2id.lookup(name).default(Skill-id(0))
-
-// Get the name for a skill.
-// Inherited skills have `" (Inherited)"` appended to their names.
-// If no skill matches the ID, the result is the numeric ID.
-pub fun show(s: skill-id): string
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> {{ printf "%q" $s.Name }}{{ if $s.InheritID }} ++ " (Inherited)"{{ end }}
-    {{- end }}
-    x -> "skill " ++ x.show
-
-// Get the description for a skill.
-// If no skill matches the ID, the result is the empty string.
-pub fun description(s: skill-id): string
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> {{ printf "%q" $s.Description }}
-    {{- end }}
-    _ -> ""
-
-// Get the skill group ID for a skill.
-// If no skill matches the ID, the result is an invalid ID.
-pub fun group(s: skill-id): skill-group-id
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> Skill-group-id( {{- $s.GroupID -}} )
-    {{- end }}
-    _ -> Skill-group-id(0)
-
-// Get the rarity of a skill.
-// If no skill matches the ID, the result is Common.
-pub fun rarity(s: skill-id): rarity
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> {{ if eq $s.Rarity 1 }}Common{{ else if eq $s.Rarity 2 }}Rare{{ else if eq $s.Rarity 3 }}Unique-Low{{ else if eq $s.Rarity 4 }}Unique-Upgraded{{ else if eq $s.Rarity 5 }}Unique{{ else }}??? $s.Rarity={{ $s.Rarity }}{{ end }}
-    {{- end }}
-    _ -> Common
-
-// Get the group rate of a skill.
-// If no skill matches the ID, the result is 0.
-pub fun group-rate(s: skill-id): int
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> {{ $s.GroupRate }}
-    {{- end }}
-    _ -> 0
-
-// Get the grade value of a skill.
-// If no skill matches the ID, the result is 0.
-pub fun grade-value(s: skill-id): int
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> {{ $s.GradeValue }}
-    {{- end }}
-    _ -> 0
-
-// Get whether a skill is a wit check.
-// If no skill matches the ID, the result is False.
-pub fun wit-check(s: skill-id): bool
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> {{ if $s.WitCheck }}True{{ else }}False{{ end }}
-    {{- end }}
-    _ -> False
-
-// Get the activations of a skill.
-// If no skill matches the ID, the result is an empty list.
-pub fun activations(s: skill-id): list<activation>
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> [
-      {{- range $a := $s.Activations }}
-      {{- if $a.Condition }}
-      Activation(
-        precondition = {{ printf "%q" $a.Precondition }},
-        condition = {{ printf "%q" $a.Condition }},
-        duration = {{ $a.Duration }}.decimal{{ if gt $a.Duration 0 }}(-4){{ end }},
-        cooldown = {{ $a.Cooldown }}.decimal{{ if gt $a.Cooldown 0 }}(-4){{ end }},
-        abilities = [
-          {{- range $abil := $a.Abilities }}
-          {{- if $abil.Type }}
-          Ability(
-            ability-type = {{ if eq $abil.Type 1 }}Passive-Speed({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 2 }}Passive-Stamina({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 3 }}Passive-Power({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 4 }}Passive-Guts({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 5 }}Passive-Wit({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 6 }}Great-Escape
-              {{- else if eq $abil.Type 8 }}Vision({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 9 }}HP({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 10 }}Gate-Delay({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 13 }}Frenzy({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 21 }}Current-Speed({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 27 }}Target-Speed({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 28 }}Lane-Speed({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 31 }}Accel({{ $abil.Value }}.decimal(-4))
-              {{- else if eq $abil.Type 35 }}Lane-Change({{ $abil.Value }}.decimal(-4))
-              {{- else }}??? $abil.Type={{$abil.Type}}
-            {{- end }},
-            value-usage = {{ if eq $abil.ValueUsage 1 }}Direct
-              {{- else if eq $abil.ValueUsage 3 }}Team-Speed
-              {{- else if eq $abil.ValueUsage 4 }}Team-Stamina
-              {{- else if eq $abil.ValueUsage 5 }}Team-Power
-              {{- else if eq $abil.ValueUsage 6 }}Team-Guts
-              {{- else if eq $abil.ValueUsage 7 }}Team-Wit
-              {{- else if eq $abil.ValueUsage 8 }}Multiply-Random
-              {{- else if eq $abil.ValueUsage 9 }}Multiply-Random2
-              {{- else if eq $abil.ValueUsage 10 }}Climax
-              {{- else if eq $abil.ValueUsage 13 }}Max-Stat
-              {{- else if eq $abil.ValueUsage 14 }}Passive-Count
-              {{- else if eq $abil.ValueUsage 19 }}Front-Distance-Add
-              {{- else if eq $abil.ValueUsage 20 }}Midrace-Side-Block-Time
-              {{- else if eq $abil.ValueUsage 22 }}Speed-Scaling
-              {{- else if eq $abil.ValueUsage 23 }}Speed-Scaling2
-              {{- else if eq $abil.ValueUsage 24 }}Arc-Global-Potential
-              {{- else if eq $abil.ValueUsage 25 }}Max-Lead-Distance
-              {{- else }}??? $abil.ValueUsage={{ $abil.ValueUsage }}
-            {{- end }},
-            target = {{ if eq $abil.Target 1}}Self
-              {{- else if eq $abil.Target 4 }}Sympathizers
-              {{- else if eq $abil.Target 4 }}In-View
-              {{- else if eq $abil.Target 4 }}Frontmost
-              {{- else if eq $abil.Target 9 }}Ahead({{ $abil.TargetValue }})
-              {{- else if eq $abil.Target 10 }}Behind({{ $abil.TargetValue }})
-              {{- else if eq $abil.Target 4 }}All-Teammates
-              {{- else if eq $abil.Target 18 }}Style({{ if eq $abil.TargetValue 1 }}Front-Runner{{ else if eq $abil.TargetValue 2 }}Pace-Chaser{{ else if eq $abil.TargetValue 3 }}Late-Surger{{ else if eq $abil.TargetValue 4 }}End-Closer{{ else }}??? $abil.TargetValue={{ $abil.TargetValue }}{{ end }})
-              {{- else if eq $abil.Target 19 }}Rushing-Ahead({{ $abil.TargetValue }})
-              {{- else if eq $abil.Target 20 }}Rushing-Behind({{ $abil.TargetValue }})
-              {{- else if eq $abil.Target 21 }}Rushing-Style({{ if eq $abil.TargetValue 1 }}Front-Runner{{ else if eq $abil.TargetValue 2 }}Pace-Chaser{{ else if eq $abil.TargetValue 3 }}Late-Surger{{ else if eq $abil.TargetValue 4 }}End-Closer{{ else }}??? $abil.TargetValue={{ $abil.TargetValue }}{{ end }})
-              {{- else if eq $abil.Target 22 }}Specific-Character(Character-id({{ $abil.TargetValue }}))
-              {{- else if eq $abil.Target 23 }}Triggering
-            {{- end }}
-          ),
-          {{- end }}
-          {{- end }}
-        ]
-      ),
-      {{- end }}
-      {{- end }}
-    ]
-    {{- end }}
-    _ -> Nil
-
-// Get the owner of a unique skill.
-// If the skill is not unique, or if there is no skill with the given ID,
-// the result is Nothing.
-pub fun unique-owner(s: skill-id): maybe<trainee-id>
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{- if $s.UniqueOwnerID }}
-    {{ $s.ID }} -> Just(Trainee-id({{ $s.UniqueOwnerID }}))
-    {{- end }}
-    {{- end }}
-    _ -> Nothing
-
-// Get the SP cost of a skill.
-// If there is no skill with the given ID, the result is 0.
-pub fun sp-cost(s: skill-id): int
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> {{ $s.SPCost }}
-    {{- end }}
-    _ -> 0
-
-// Get the icon ID of a skill.
-// If there is no skill with the given ID, the result is an invalid ID.
-pub fun icon-id(s: skill-id): skill-icon-id
-  match s.game-id
-    {{- range $s := $.Skills }}
-    {{ $s.ID }} -> Skill-icon-id({{ $s.IconID }})
-    {{- end }}
-    _ -> Skill-icon-id(0)
-
-// Get the name for a skill group.
-// Skill group names are the name of the base skill in the group.
-// If there is no skill group with the given ID, the result is the numeric ID.
-pub fun skill-group/show(sg: skill-group-id): string
-  match sg.game-id
-    {{- range $g := $.Groups }}
-    {{ $g.ID }} -> {{- printf "%q" $g.Name -}}
-    {{- end }}
-    x -> "skill group " ++ x.show
-
-// Get the list of skills in a skill group.
-pub fun skill-group/skills(sg: skill-group-id): list<skill-id>
-  match sg.game-id
-    {{- range $g := $.Groups }}
-    {{ $g.ID }} -> [ {{- range $s := index $.Related $g.ID }}Skill-id({{ $s.ID }}), {{ end -}} ]
-    {{- end }}
-    _ -> Nil
-
-{{- end }}

horsegen/spark.go.template

@@ -1,35 +0,0 @@
-{{- define "go-spark" -}}
-package {{ $.Region }}
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import . "git.sunturtle.xyz/zephyr/horse/horse"
-
-const (
-	{{- range $s := $.Sparks }}
-	Spark{{ goenum $s.Name }}Lv{{ $s.Rarity }} SparkID = {{ $s.ID }} // {{ $s.Name }}
-	{{- end }}
-)
-
-var AllSparks = map[SparkID]Spark{
-	{{- range $s := $.Sparks }}
-	Spark{{ goenum $s.Name }}Lv{{ $s.Rarity }}: {
-		ID: {{ $s.ID }},
-		Name: {{ printf "%q" $s.Name }},
-		Description: {{ printf "%q" $s.Description }},
-		Group: {{ $s.Group }},
-		Rarity: {{ $s.Rarity }},
-		Type: {{ $s.Type }},
-		Effects: [][]SparkEffect{
-			{{- range $r := index $.SparkEffects $s.Group }}
-			{
-				{{- range $e := $r -}}
-				{ {{- $e.Target }}, {{ $e.Value1 }}, {{ $e.Value2 -}} },
-				{{- end -}}
-			},
-			{{- end }}
-		},
-	},
-	{{- end }}
-}
-{{ end }}

horsegen/spark.kk.template

@@ -1,132 +0,0 @@
-{{- define "koka-spark" -}}
-module horse/{{ $.Region }}/spark
-
-// Automatically generated with horsegen; DO NOT EDIT
-
-import horse/game-id
-pub import horse/spark
-
-// Enumeration of all sparks for type-safe programming.
-pub type spark
-  {{- range $s := $.Sparks }}
-  {{ kkenum $s.Name }}-Lv{{ $s.Rarity }}
-  {{- end }}
-
-// Get the ID for a spark.
-pub fun spark-id(s: spark): spark-id
-  match s
-    {{- range $s := $.Sparks }}
-    {{ kkenum $s.Name }}-Lv{{ $s.Rarity }} -> Spark-id({{ $s.ID }})
-    {{- end }}
-
-// List of all sparks in ID order for easy iterating.
-pub val all = [
-  {{- range $s := $.Sparks }}
-  {{ kkenum $s.Name }}-Lv{{ $s.Rarity }},
-  {{- end }}
-]
-
-// Get the name for a spark.
-// The name does not indicate the spark level.
-// If no spark matches the ID, the result contains the numeric ID.
-pub fun show(s: spark-id): string
-  match s.game-id
-    {{- range $s := $.Sparks }}
-    {{ $s.ID }} -> {{ printf "%q" $s.Name }}
-    {{- end }}
-    x -> "spark " ++ x.show
-
-// Get the description for a spark.
-// The description does not indicate the spark level.
-// If no spark matches the ID, the result contains the numeric ID.
-pub fun description(s: spark-id): string
-  match s.game-id
-    {{- range $s := $.Sparks }}
-    {{ $s.ID }} -> {{ printf "%q" $s.Description }}
-    {{- end }}
-    x -> "spark " ++ x.show
-
-// Get the spark group ID of a spark.
-// If no spark matches the ID, the result is an invalid ID.
-pub fun spark-group(s: spark-id): spark-group-id
-  match s.game-id
-    {{- range $s := $.Sparks }}
-    {{ $s.ID }} -> Spark-group-id({{ $s.Group }})
-    {{- end }}
-    _ -> Spark-group-id(0)
-
-// Get the rarity (level or star count) of a spark.
-// If no spark matches the ID, the result is One.
-pub fun rarity(s: spark-id): rarity
-  match s.game-id
-    {{- range $s := $.Sparks }}
-    {{ $s.ID }} -> {{ if eq $s.Rarity 1 }}One{{ else if eq $s.Rarity 2 }}Two{{ else if eq $s.Rarity 3 }}Three{{ else }}??? $s.Rarity={{ $s.Rarity }}{{ end }}
-    {{- end }}
-    _ -> One
-
-// Get the type of a spark.
-// If no spark matches the ID, the result is Stat.
-pub fun spark-type(s: spark-id): spark-type
-  match s.game-id
-    {{- range $s := $.Sparks }}
-    {{ $s.ID }} -> {{ if eq $s.Type 1 }}Stat
-      {{- else if eq $s.Type 2 }}Aptitude
-      {{- else if eq $s.Type 5 }}Race
-      {{- else if eq $s.Type 4 }}Skill
-      {{- else if eq $s.Type 6 }}Scenario
-      {{- else if eq $s.Type 7 }}Carnival-Bonus
-      {{- else if eq $s.Type 10 }}Surface
-      {{- else if eq $s.Type 8 }}Distance
-      {{- else if eq $s.Type 11 }}Style
-      {{- else if eq $s.Type 9 }}Hidden
-      {{- else if eq $s.Type 3 }}Unique
-      {{- else }}??? $s.Type={{ $s.Type }}
-      {{- end }}
-    {{- end }}
-    _ -> Stat
-
-// Get the list of all effects a spark can apply during inheritance.
-// When a spark procs, a random element is chosen from the list yielded by this
-// function according to a hidden distribution, then all effects in that are applied.
-// If no spark matches the ID, the result is the empty list.
-pub fun effects(s: spark-id): list<list<spark-effect>>
-  match s.game-id
-    {{- range $s := $.Sparks }}
-    {{ $s.ID }} -> [
-      {{- range $r := index $.SparkEffects $s.Group }}
-      [
-        {{- range $e := $r -}}
-        {{- if eq $e.Target 1 -}}Stat-Up(Speed, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 2 -}}Stat-Up(Stamina, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 3 -}}Stat-Up(Power, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 4 -}}Stat-Up(Guts, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 5 -}}Stat-Up(Wit, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 6 -}}SP-Up({{ $e.Value1 }}),
-        {{- else if eq $e.Target 7 -}}Random-Stat-Up({{ $e.Value1 }}),
-        {{- else if eq $e.Target 11 -}}Aptitude-Up(Turf, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 12 -}}Aptitude-Up(Dirt, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 21 -}}Aptitude-Up(Front-Runner, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 22 -}}Aptitude-Up(Pace-Chaser, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 23 -}}Aptitude-Up(Late-Surger, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 24 -}}Aptitude-Up(End-Closer, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 31 -}}Aptitude-Up(Sprint, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 32 -}}Aptitude-Up(Mile, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 33 -}}Aptitude-Up(Medium, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 34 -}}Aptitude-Up(Long, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 41 -}}Skill-Hint(Skill-id({{ $e.Value1 }}), {{ $e.Value2 }}),
-        {{- else if eq $e.Target 51 -}}Carnival-Bonus {{/*- skipped, but doesn't hurt to put it here -*/}}
-        {{- else if eq $e.Target 61 -}}Stat-Cap-Up(Speed, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 62 -}}Stat-Cap-Up(Stamina, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 63 -}}Stat-Cap-Up(Power, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 64 -}}Stat-Cap-Up(Guts, {{ $e.Value1 }}),
-        {{- else if eq $e.Target 65 -}}Stat-Cap-Up(Wit, {{ $e.Value1 }}),
-        {{- else -}}
-        ??? $e.Target={{- $e.Target -}}
-        {{- end -}}
-        {{- end -}}
-      ],
-      {{- end }}
-    ]
-    {{- end }}
-    _ -> []
-{{ end }}

schema/schema.ts

@@ -0,0 +1,420 @@
+/**
+ * TypeScript schema for JSON files generated by horsegen.
+ */
+
+/**
+ * Character definitions.
+ */
+export interface Character {
+	/**
+	 * Character ID.
+	 */
+	chara_id: number;
+	/**
+	 * Regional name of the character.
+	 * E.g., Special Week for Global, or スペシャルウィーク for JP.
+	 */
+	name: string;
+}
+
+/**
+ * Precomputed character pair and trio affinity.
+ */
+export interface Affinity {
+	/**
+	 * First character in the relation.
+	 */
+	chara_a: number;
+	/**
+	 * Second character in the relation.
+	 * chara_a < chara_b is an invariant.
+	 */
+	chara_b: number;
+	/**
+	 * Third character in the relation, if it is a trio relation.
+	 * If defined, chara_b < chara_c is an invariant.
+	 */
+	chara_c?: number;
+	/**
+	 * Total base compatibility between characters in the relation.
+	 */
+	affinity: number;
+}
+
+/**
+ * Uma or character card definitions.
+ */
+export interface Uma {
+	/**
+	 * Uma ID.
+	 */
+	chara_card_id: number;
+	/**
+	 * Character ID that the Uma is a variant of.
+	 */
+	chara_id: number;
+	/**
+	 * Regional name of the Uma, comprised of the variant name and the character name.
+	 * E.g. "[Special Dreamer] Special Week".
+	 */
+	name: string;
+	/**
+	 * Regional variant name.
+	 * E.g. "[Special Dreamer]".
+	 */
+	variant: string;
+
+	sprint: AptitudeLevel;
+	mile: AptitudeLevel;
+	medium: AptitudeLevel;
+	long: AptitudeLevel;
+	front: AptitudeLevel;
+	pace: AptitudeLevel;
+	late: AptitudeLevel;
+	end: AptitudeLevel;
+	turf: AptitudeLevel;
+	dirt: AptitudeLevel;
+
+	/**
+	 * ID of the Uma's unique skill.
+	 */
+	unique: number;
+	/**
+	 * ID of the Uma's first built-in skill.
+	 */
+	skill1: number;
+	/**
+	 * ID of the Uma's second built-in skill.
+	 */
+	skill2: number;
+	/**
+	 * ID of the Uma's third built-in skill.
+	 */
+	skill3: number;
+	/**
+	 * ID of the skill unlocked at potential level 2.
+	 */
+	skill_pl2: number;
+	/**
+	 * ID of the skill unlocked at potential level 3.
+	 */
+	skill_pl3: number;
+	/**
+	 * ID of the skill unlocked at potential level 4.
+	 */
+	skill_pl4: number;
+	/**
+	 * ID of the skill unlocked at potential level 5.
+	 */
+	skill_pl5: number;
+}
+
+export type AptitudeLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+
+/**
+ * Race data.
+ */
+export interface Race {
+	/**
+	 * Race ID.
+	 */
+	race_id: number;
+	/**
+	 * Regional name of the race.
+	 */
+	name: string;
+	/**
+	 * Thumbnail asset ID number.
+	 */
+	thumbnail: number;
+	/**
+	 * Primary race ID.
+	 * For most races, this is the same as race_id. Some races are alternate
+	 * versions for certain careers; this holds the ID of the normal version of
+	 * the race.
+	 */
+	primary: number;
+}
+
+/**
+ * Race saddle data.
+ */
+export interface Saddle {
+	/**
+	 * Saddle ID.
+	 */
+	saddle_id: number;
+	/**
+	 * Regional name of the saddle.
+	 */
+	name: string;
+	/**
+	 * IDs of race wins required to earn the saddle.
+	 */
+	races: number[];
+	/**
+	 * Saddle type: 0 for multi-race honors, 3 for G1, 2 for G2, 1 for G3.
+	 */
+	type: 0 | 1 | 2 | 3;
+	/**
+	 * Primary saddle ID.
+	 * Respective for races.
+	 */
+	primary: number;
+}
+
+/**
+ * Scenario data.
+ */
+export interface Scenario {
+	/**
+	 * Scenario ID.
+	 */
+	scenario_id: number;
+	/**
+	 * Regional scenario name, e.g. "TS Climax".
+	 */
+	name: string;
+	/**
+	 * Regional full title, e.g. "Trackblazer: Start of the Climax".
+	 */
+	title: string;
+}
+
+/**
+ * Skill data.
+ */
+export interface Skill {
+	/**
+	 * Skill ID.
+	 */
+	skill_id: number;
+	/**
+	 * Regional skill name.
+	 */
+	name: string;
+	/**
+	 * Regional skil description.
+	 */
+	description: string;
+	/**
+	 * Skill group ID.
+	 */
+	group: number;
+	/**
+	 * Skill rarity. 3-5 are uniques for various star levels.
+	 */
+	rarity: 1 | 2 | 3 | 4 | 5;
+	/**
+	 * Upgrade position within the skill's group.
+	 * -1 is for negative (purple) skills.
+	 */
+	group_rate: 1 | 2 | 3 | -1;
+	/**
+	 * Grade value, or the amount of rating gained for having the skill with
+	 * appropriate aptitude.
+	 */
+	grade_value?: number;
+	/**
+	 * Whether the skill requires a wit check.
+	 */
+	wit_check: boolean;
+	/**
+	 * Conditions and results of skill activation.
+	 */
+	activations: [Activation] | [Activation, Activation];
+	/**
+	 * Name of the Uma which owns this skill as a unique, if applicable.
+	 */
+	unique_owner?: string;
+	/**
+	 * SP cost to purchase the skill, if applicable.
+	 */
+	sp_cost?: number;
+	/**
+	 * Skill icon ID.
+	 */
+	icon_id: number;
+}
+
+/**
+ * Conditions and results of skill activation.
+ */
+export interface Activation {
+	/**
+	 * Precondition which must be satisfied before the condition is checked.
+	 */
+	precondition?: string;
+	/**
+	 * Activation conditions.
+	 */
+	condition: string;
+	/**
+	 * Skill duration in ten thousandths of a second.
+	 * Generally undefined for activations which only affect HP.
+	 */
+	duration?: number;
+	/**
+	 * Special skill duration scaling mode.
+	 */
+	dur_scale: 1 | 2 | 3 | 4 | 5 | 7;
+	/**
+	 * Skill cooldown in ten thousandths of a second.
+	 * A value of 5000000 indicates that the cooldown is forever.
+	 * Generally undefined for passive skills.
+	 */
+	cooldown?: number;
+	/**
+	 * Results applied when the skill's conditions are met.
+	 */
+	abilities: [Ability] | [Ability, Ability] | [Ability, Ability, Ability];
+}
+
+/**
+ * Effects applied when a skill activates.
+ */
+export interface Ability {
+	/**
+	 * Race mechanic affected by the ability.
+	 */
+	type: 1 | 2 | 3 | 4 | 5 | 6 | 8 | 9 | 10 | 13 | 21 | 27 | 28 | 31 | 35;
+	/**
+	 * Special scaling type of the skill value.
+	 */
+	value_usage: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 13 | 14 | 19 | 20 | 22 | 23 | 24 | 25;
+	/**
+	 * Amount that the skill modifies the race mechanic in ten thousandths of
+	 * whatever is the appropriate unit.
+	 */
+	value: number;
+	/**
+	 * Selector for horses targeted by the ability.
+	 */
+	target: 1 | 2 | 4 | 7 | 9 | 10 | 11 | 18 | 19 | 20 | 21 | 22 | 23;
+	/**
+	 * Argument value for the ability target, when appropriate.
+	 */
+	target_value?: number;
+}
+
+/**
+ * Skill groups.
+ * Skills in a skill group replace each other when purchased.
+ * 
+ * As a special case, horsegen lists both unique skills and their inherited
+ * versions in the skill groups for both.
+ */
+export interface SkillGroup {
+	/**
+	 * Skill group ID.
+	 */
+	skill_group: number;
+	/**
+	 * Base skill in the skill group, if any.
+	 * Either a common (white) skill or an Uma's own unique.
+	 * 
+	 * Some skill groups, e.g. for G1 Averseness, have no base skill.
+	 */
+	skill1?: number;
+	/**
+	 * First upgraded version of a skill, if any.
+	 * A rare (gold) skill, double circle skill, or an inherited unique skill.
+	 */
+	skill2?: number;
+	/**
+	 * Highest upgraded version of a skill, if any.
+	 * Gold version of a skill with a double circle version.
+	 */
+	skill3?: number;
+	/**
+	 * Negative (purple) version of a skill, if any.
+	 */
+	skill_bad?: number;
+}
+
+/**
+ * Sparks, or succession factors.
+ */
+export interface Spark {
+	/**
+	 * Spark ID.
+	 */
+	spark_id: number;
+	/**
+	 * Regional spark name.
+	 */
+	name: string;
+	/**
+	 * Regional spark description.
+	 */
+	description: string;
+	/**
+	 * Spark group.
+	 * Different star levels of a given spark are different spark IDs but
+	 * share a spark group.
+	 */
+	spark_group: number;
+	/**
+	 * Spark rarity, or star level.
+	 */
+	rarity: 1 | 2 | 3;
+	/**
+	 * Spark type.
+	 * Roughly the spark color, with extra subdivisions for white sparks.
+	 */
+	type: 1 | 2 | 5 | 4 | 6 | 7 | 10 | 8 | 11 | 9 | 3;
+	/**
+	 * Possible effects applied by the spark during inspiration.
+	 * A random element is selected from this list according to unknown
+	 * distributions, then all effects in that selection are applied.
+	 */
+	effects: SparkEffect[][];
+}
+
+/**
+ * Effects that a spark can apply.
+ */
+export interface SparkEffect {
+	target: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 11 | 12 | 21 | 22 | 23 | 24 | 31 | 32 | 33 | 34 | 41 | 51 | 61 | 62 | 63 | 64 | 65;
+	value1?: number;
+	value2: number;
+}
+
+/**
+ * Lobby conversation data.
+ */
+export interface Conversation {
+	/**
+	 * Character who owns the conversation as a gallery entry.
+	 */
+	chara_id: number;
+	/**
+	 * Number of the conversation within the character's conversation gallery.
+	 */
+	number: number;
+	/**
+	 * Location ID of the conversation.
+	 */
+	location: 110 | 120 | 130 | 210 | 220 | 310 | 410 | 420 | 430 | 510 | 520 | 530;
+	/**
+	 * English name of the location, for convenience.
+	 */
+	location_name: string;
+	/**
+	 * First character in the conversation.
+	 * Not necessarily equal to chara_id.
+	 */
+	chara_1: number;
+	/**
+	 * Second character, if present.
+	 */
+	chara_2?: number;
+	/**
+	 * Third character, if present.
+	 */
+	chara_3?: number;
+	/**
+	 * Some unknown number in the game's local database.
+	 */
+	condition_type: 0 | 1 | 2 | 3 | 4;
+}

test/example.kk

@@ -0,0 +1,295 @@
+module test/example
+
+import std/num/decimal
+import std/data/linearmap
+import horse/game-id
+import horse/global
+import horse/global/character
+import horse/global/saddle
+import horse/global/skill
+import horse/global/spark
+import horse/global/uma
+import horse/legacy
+
+val p1 = Legacy(
+  uma = Veteran(
+    uma = Uma-id(102001), // seiun sky
+    sparks = [
+      301, // 1* power
+      2102, // 2* front runner
+      10200103, // 3* angling and scheming
+      1000302, // 2* osaka hai
+      1001001, // 1* japanese derby
+      1001101, // 1* yasuda kinen
+      1001701, // 1* qe2
+      2001402, // 2* non-standard distance
+      2004301, // 1* focus
+      2005301, // 1* early lead
+      2012401, // 1* front runner straightaways
+      2012502, // 2* front runner corners
+      2015201, // 1* front runner savvy
+      2016001, // 1* groundwork
+      2016102, // 2* thh
+      2016402, // 2* lone wolf
+      3000201, // 1* unity cup
+    ].map(Spark-id(_)),
+    saddles = [
+      1, // classic triple crown
+      2, // senior autumn triple crown
+      4, // senior spring triple crown
+      5, // tenno sweep
+      6, // dual grand prix
+      7, // dual miles
+      10, // arima kinen
+      11, // japan cup
+      12, // derby
+      13, // tss
+      14, // takarazuka kinen
+      15, // tsa
+      16, // kikuka sho
+      17, // osaka hai
+      18, // satsuki sho
+      21, // yasuda kinen
+      23, // mile championship
+      25, // victoria mile
+      26, // qe2
+      33, // asahi hai fs
+      34, // hopeful stakes
+      96, // mainichi hai
+    ].map(Saddle-id(_))
+  ),
+  sub1 = Veteran(
+    uma = Uma-id(102601), // mihono bourbon
+    sparks = [
+      302, // 2* power
+      3303, // 3* medium
+      10260102, // 2* g00 1st
+      1001201, // 1* takarazuka kinen
+      1001702, // 2* qe2
+      1001901, // 1* japan cup
+      2004302, // 2* focus
+      2004502, // 2* prudent positioning
+      2012502, // 2* front corners
+      2015202, // 2* front savvy
+      2016002, // 2* groundwork
+      2016401, // 1* lone wolf
+      3000201, // 1* unity cup
+    ].map(Spark-id(_)),
+    saddles = [
+      2, // senior autumn triple crown
+      6, // dual grand prix
+      7, // dual miles
+      10, // arima kinen
+      11, // japan cup
+      12, // derby
+      14, // takarazuka kinen
+      15, // tsa
+      17, // osaka hai
+      18, // satsuki sho
+      21, // yasuda kinen
+      23, // mile championship
+      25, // victoria mile
+      26, // qe2
+      27, // nhk mile cup
+      33, // asahi hai fs
+      34, // hopeful stakes
+      49, // spring stakes
+    ].map(Saddle-id(_))
+  ),
+  sub2 = Veteran(
+    uma = Uma-id(102401), // mayano top gun
+    sparks = [
+      302, // 2* power
+      1103, // 3* turf
+      10240101, // 1* flashy landing
+      1000601, // 1* tss
+      1001202, // 2* takarazuka kinen
+      1001502, // 2* kikuka sho
+      1001601, // 1* tsa
+      1002102, // 2* hanshin jf
+      1002301, // 1* arima kinen
+      2003503, // 3* corner recovery
+      2003802, // 2* straightaway recovery
+      2004602, // 2* ramp up
+      2005502, // 2* final push
+      2012702, // 2* leader's pride
+      2016002, // 2* groundwork
+      3000102, // 2* ura finale
+    ].map(Spark-id(_)),
+    saddles = [
+      1, // classic triple crown
+      2, // senior autumn triple crown
+      4, // senior spring triple crown
+      5, // tenno sweep
+      6, // dual grand prix
+      7, // dual miles
+      10, // arima kinen
+      11, // japan cup
+      12, // derby
+      13, // tss
+      14, // takarazuka kinen
+      15, // tsa
+      16, // kikuka sho
+      18, // satsuki sho
+      21, // yasuda kinen
+      23, // mile championship
+      25, // victoria mile
+      26, // qe2
+      34, // hopeful stakes
+      35, // hanshin jf
+    ].map(Saddle-id(_))
+  )
+)
+
+val p2 = Legacy(
+  uma = Veteran(
+    uma = Uma-id(102601), // mihono bourbon
+    sparks = [
+      302,
+      3303,
+      1001201,
+      1001702,
+      1001901,
+      2004302,
+      2004502,
+      2012502,
+      2015202,
+      2016002,
+      2016401,
+      3000201,
+      10260102,
+    ].map(Spark-id(_)),
+    saddles = [
+      2,
+      6,
+      7,
+      10,
+      11,
+      12,
+      14,
+      15,
+      17,
+      18,
+      21,
+      23,
+      25,
+      26,
+      27,
+      33,
+      34,
+      49,
+    ].map(Saddle-id(_))
+  ),
+  sub1 = Veteran(
+    uma = Uma-id(102402), // wedding mayano
+    sparks = [
+      203,
+      3202,
+      1000701,
+      1000802,
+      1001201,
+      1001803,
+      2003502,
+      2003701,
+      2004301,
+      2005502,
+      2012401,
+      2016402,
+      10240202,
+    ].map(Spark-id(_)),
+    saddles = [
+      1,
+      2,
+      6,
+      7,
+      10,
+      11,
+      12,
+      14,
+      15,
+      16,
+      18,
+      21,
+      23,
+      25,
+      26,
+      27,
+      33,
+      34,
+      48,
+    ].map(Saddle-id(_))
+  ),
+  sub2 = Veteran(
+    uma = Uma-id(100201), // silence suzuka
+    sparks = [
+      203,
+      1101,
+      1001901,
+      1002203,
+      1002302,
+      2000101,
+      2000201,
+      2001902,
+      2003501,
+      2005401,
+      2016001,
+      3000102,
+      10020101,
+    ].map(Spark-id(_)),
+    saddles = [
+      2,
+      6,
+      10,
+      11,
+      12,
+      14,
+      15,
+      17,
+      18,
+      21,
+      25,
+      26,
+      27,
+      33,
+      34,
+      40,
+      42,
+      44,
+      45,
+      46,
+      49,
+      59,
+      61,
+      63,
+      65,
+      111,
+      113,
+      117,
+      126,
+    ].map(Saddle-id(_))
+  )
+)
+
+val trainee = Uma-id(104601) // smart falcon
+
+pub fun main()
+  val p1a = parent-affinity(trainee, p1, p2.uma.uma)
+  val p2a = parent-affinity(trainee, p2, p1.uma.uma)
+  val (s11a, s12a) = sub-affinity(trainee, p1)
+  val (s21a, s22a) = sub-affinity(trainee, p2)
+  println("trainee: " ++ trainee.show)
+  println("p1: " ++ p1.uma.uma.show ++ " affinity " ++ p1a.show)
+  println("s1-1: " ++ p1.sub1.uma.show ++ " affinity " ++ s11a.show)
+  println("s1-2: " ++ p1.sub2.uma.show ++ " affinity " ++ s12a.show)
+  println("p2: " ++ p2.uma.uma.show ++ " affinity " ++ p1a.show)
+  println("s1-1: " ++ p2.sub1.uma.show ++ " affinity " ++ s21a.show)
+  println("s1-2: " ++ p2.sub2.uma.show ++ " affinity " ++ s22a.show)
+  val inspo = inspiration(trainee, p1, p2)
+  val s = inspiration-gives(inspo, legacy/skills)
+  val a = inspiration-gives(inspo, legacy/aptitudes)
+  println("\nskills:")
+  s.list.foreach() fn((skill, pmf))
+    println("  " ++ skill.show ++ ": " ++ pmf.show)
+  println("\naptitudes:")
+  a.list.foreach() fn((apt, pmf))
+    println("  " ++ apt.show ++ ": " ++ pmf.show)

test/global.kk

@@ -0,0 +1,12 @@
+module test/global
+
+import horse/global/character
+import horse/global/race
+import horse/global/saddle
+import horse/global/scenario
+import horse/global/skill
+import horse/global/spark
+import horse/global/uma
+
+pub fun main()
+  ()

zenno/.gitignore

@@ -0,0 +1,23 @@
+node_modules
+
+# Output
+.output
+.vercel
+.netlify
+.wrangler
+/.svelte-kit
+/build
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Env
+.env
+.env.*
+!.env.example
+!.env.test
+
+# Vite
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*

zenno/.npmrc

@@ -0,0 +1 @@
+engine-strict=true

zenno/.prettierignore

@@ -0,0 +1,9 @@
+# Package Managers
+package-lock.json
+pnpm-lock.yaml
+yarn.lock
+bun.lock
+bun.lockb
+
+# Miscellaneous
+/static/

zenno/.prettierrc

@@ -0,0 +1,16 @@
+{
+	"useTabs": true,
+	"singleQuote": true,
+	"trailingComma": "all",
+	"printWidth": 130,
+	"plugins": ["prettier-plugin-svelte", "prettier-plugin-tailwindcss"],
+	"overrides": [
+		{
+			"files": "*.svelte",
+			"options": {
+				"parser": "svelte"
+			}
+		}
+	],
+	"tailwindStylesheet": "./src/routes/layout.css"
+}

zenno/README.md

@@ -0,0 +1,42 @@
+# sv
+
+Everything you need to build a Svelte project, powered by [`sv`](https://github.com/sveltejs/cli).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```sh
+# create a new project
+npx sv create my-app
+```
+
+To recreate this project with the same configuration:
+
+```sh
+# recreate this project
+npx sv@0.13.0 create --template minimal --types ts --add prettier eslint vitest="usages:unit,component" tailwindcss="plugins:none" --install npm zenno
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```sh
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+## Building
+
+To create a production version of your app:
+
+```sh
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.

zenno/eslint.config.js

@@ -0,0 +1,39 @@
+import prettier from 'eslint-config-prettier';
+import path from 'node:path';
+import { includeIgnoreFile } from '@eslint/compat';
+import js from '@eslint/js';
+import svelte from 'eslint-plugin-svelte';
+import { defineConfig } from 'eslint/config';
+import globals from 'globals';
+import ts from 'typescript-eslint';
+import svelteConfig from './svelte.config.js';
+
+const gitignorePath = path.resolve(import.meta.dirname, '.gitignore');
+
+export default defineConfig(
+	includeIgnoreFile(gitignorePath),
+	js.configs.recommended,
+	ts.configs.recommended,
+	svelte.configs.recommended,
+	prettier,
+	svelte.configs.prettier,
+	{
+		languageOptions: { globals: { ...globals.browser, ...globals.node } },
+		rules: {
+			// typescript-eslint strongly recommend that you do not use the no-undef lint rule on TypeScript projects.
+			// see: https://typescript-eslint.io/troubleshooting/faqs/eslint/#i-get-errors-from-the-no-undef-rule-about-global-variables-not-being-defined-even-though-there-are-no-typescript-errors
+			'no-undef': 'off',
+		},
+	},
+	{
+		files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'],
+		languageOptions: {
+			parserOptions: {
+				projectService: true,
+				extraFileExtensions: ['.svelte'],
+				parser: ts.parser,
+				svelteConfig,
+			},
+		},
+	},
+);

zenno/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "zenno",
+	"private": true,
+	"version": "0.0.1",
+	"type": "module",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build",
+		"preview": "vite preview",
+		"prepare": "svelte-kit sync || echo ''",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"lint": "prettier --check . && eslint .",
+		"format": "prettier --write .",
+		"test:unit": "vitest",
+		"test": "npm run test:unit -- --run"
+	},
+	"devDependencies": {
+		"@eslint/compat": "^2.0.3",
+		"@eslint/js": "^10.0.1",
+		"@sveltejs/adapter-auto": "^7.0.0",
+		"@sveltejs/adapter-static": "^3.0.10",
+		"@sveltejs/kit": "^2.50.2",
+		"@sveltejs/vite-plugin-svelte": "^6.2.4",
+		"@tailwindcss/vite": "^4.1.18",
+		"@types/node": "^22",
+		"@vitest/browser-playwright": "^4.1.0",
+		"eslint": "^10.0.3",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-svelte": "^3.15.2",
+		"globals": "^17.4.0",
+		"playwright": "^1.58.2",
+		"prettier": "^3.8.1",
+		"prettier-plugin-svelte": "^3.4.1",
+		"prettier-plugin-tailwindcss": "^0.7.2",
+		"svelte": "^5.54.0",
+		"svelte-check": "^4.4.2",
+		"tailwindcss": "^4.1.18",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.57.0",
+		"vite": "^7.3.1",
+		"vitest": "^4.1.0",
+		"vitest-browser-svelte": "^2.0.2"
+	}
+}

zenno/src/app.d.ts

@@ -0,0 +1,13 @@
+// See https://svelte.dev/docs/kit/types#app.d.ts
+// for information about these interfaces
+declare global {
+	namespace App {
+		// interface Error {}
+		// interface Locals {}
+		// interface PageData {}
+		// interface PageState {}
+		// interface Platform {}
+	}
+}
+
+export {};

zenno/src/app.html

@@ -0,0 +1,11 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		%sveltekit.head%
+	</head>
+	<body data-sveltekit-preload-data="hover">
+		<div style="display: contents">%sveltekit.body%</div>
+	</body>
+</html>

zenno/src/lib/CharaPick.svelte

@@ -0,0 +1,38 @@
+<script lang="ts">
+	import { character } from '$lib/data/character';
+	import type { ClassValue } from 'svelte/elements';
+
+	interface Props {
+		id: string;
+		value: number;
+		label?: string;
+		class?: ClassValue | null;
+		optionClass?: ClassValue | null;
+		labelClass?: ClassValue | null;
+		region?: keyof typeof character;
+		required?: boolean;
+	}
+
+	let {
+		id,
+		value = $bindable(),
+		label,
+		class: className,
+		optionClass,
+		labelClass,
+		region = 'global',
+		required = false,
+	}: Props = $props();
+</script>
+
+{#if label}
+	<label for={id} class={labelClass}>{label}</label>
+{/if}
+<select {id} class={className} bind:value {required}>
+	{#if !required}
+		<option value="0" class={optionClass}></option>
+	{/if}
+	{#each character[region] as c}
+		<option value={c.chara_id} class={optionClass}>{c.name}</option>
+	{/each}
+</select>

zenno/src/lib/data/character.ts

@@ -0,0 +1,26 @@
+import type { RegionalName } from '$lib/regional-name';
+import globalJSON from '../../../../global/character.json';
+
+/**
+ * Character definitions.
+ */
+export interface Character {
+	/**
+	 * Character ID.
+	 */
+	chara_id: number;
+	/**
+	 * Regional name of the character.
+	 * E.g., Special Week for Global, or スペシャルウィーク for JP.
+	 */
+	name: string;
+}
+
+export const character = {
+	global: globalJSON as Character[],
+};
+
+export const charaNames = globalJSON.reduce(
+	(m, c) => m.set(c.chara_id, { en: c.name }),
+	new Map<Character['chara_id'], RegionalName>(),
+);

zenno/src/lib/data/convo.ts

@@ -0,0 +1,85 @@
+import type { RegionalName } from '$lib/regional-name';
+import globalJSON from '../../../../global/conversation.json';
+
+/**
+ * Lobby conversation data.
+ */
+export interface Conversation {
+	/**
+	 * Character who owns the conversation as a gallery entry.
+	 */
+	chara_id: number;
+	/**
+	 * Number of the conversation within the character's conversation gallery.
+	 */
+	number: number;
+	/**
+	 * Location ID of the conversation.
+	 */
+	location: 110 | 120 | 130 | 210 | 220 | 310 | 410 | 420 | 430 | 510 | 520 | 530;
+	/**
+	 * English name of the location, for convenience.
+	 */
+	location_name: string;
+	/**
+	 * First character in the conversation.
+	 * Not necessarily equal to chara_id.
+	 */
+	chara_1: number;
+	/**
+	 * Second character, if present.
+	 */
+	chara_2?: number;
+	/**
+	 * Third character, if present.
+	 */
+	chara_3?: number;
+	/**
+	 * Some unknown number in the game's local database.
+	 */
+	condition_type: 0 | 1 | 2 | 3 | 4;
+}
+
+export const conversation = {
+	global: globalJSON as Conversation[],
+};
+
+export const byChara = {
+	global: globalJSON.reduce(
+		(m, c) => m.set(c.chara_id, (m.get(c.chara_id) ?? []).concat(c as Conversation)),
+		new Map<Conversation['chara_id'], Conversation[]>(),
+	),
+};
+
+export const locations: Record<Conversation['location'], { name: RegionalName; group: 1 | 2 | 3 | 4 | 5 }> = {
+	110: { name: { en: 'right side front' }, group: 1 },
+	120: { name: { en: 'right side front' }, group: 1 },
+	130: { name: { en: 'right side front' }, group: 1 },
+	210: { name: { en: 'left side table' }, group: 2 },
+	220: { name: { en: 'left side table' }, group: 2 },
+	310: { name: { en: 'center back seat' }, group: 3 },
+	410: { name: { en: 'center posters' }, group: 4 },
+	420: { name: { en: 'center posters' }, group: 4 },
+	430: { name: { en: 'center posters' }, group: 4 },
+	510: { name: { en: 'left side school map' }, group: 5 },
+	520: { name: { en: 'left side school map' }, group: 5 },
+	530: { name: { en: 'left side school map' }, group: 5 },
+};
+
+function locCharas(convos: Conversation[], locGroup: 1 | 2 | 3 | 4 | 5) {
+	const m = convos
+		.filter((c) => locations[c.location].group === locGroup)
+		.flatMap((c) => [c.chara_1, c.chara_2, c.chara_3].filter((x) => x != null))
+		.reduce((m, id) => m.set(id, 1 + (m.get(id) ?? 0)), new Map<number, number>());
+	return [...m].toSorted((a, b) => b[1] - a[1]); // descending
+}
+
+export const groupPopulars = {
+	global: {
+		1: locCharas(conversation.global, 1),
+		2: locCharas(conversation.global, 2),
+		3: locCharas(conversation.global, 3),
+		4: locCharas(conversation.global, 4),
+		5: locCharas(conversation.global, 5),
+	},
+};

zenno/src/lib/index.ts

@@ -0,0 +1 @@
+// place files you want to import through the `$lib` alias in this folder.

zenno/src/lib/regional-name.ts

@@ -0,0 +1,7 @@
+/**
+ * Names accounting for regions.
+ * Currently English is the only supported language.
+ */
+export interface RegionalName {
+	en: string;
+}

zenno/src/lib/vitest-examples/Welcome.svelte

@@ -0,0 +1,8 @@
+<script>
+	import { greet } from './greet';
+
+	let { host = 'SvelteKit', guest = 'Vitest' } = $props();
+</script>
+
+<h1>{greet(host)}</h1>
+<p>{greet(guest)}</p>

zenno/src/lib/vitest-examples/Welcome.svelte.spec.ts

@@ -0,0 +1,13 @@
+import { page } from 'vitest/browser';
+import { describe, expect, it } from 'vitest';
+import { render } from 'vitest-browser-svelte';
+import Welcome from './Welcome.svelte';
+
+describe('Welcome.svelte', () => {
+	it('renders greetings for host and guest', async () => {
+		render(Welcome, { host: 'SvelteKit', guest: 'Vitest' });
+
+		await expect.element(page.getByRole('heading', { level: 1 })).toHaveTextContent('Hello, SvelteKit!');
+		await expect.element(page.getByText('Hello, Vitest!')).toBeInTheDocument();
+	});
+});