cmd/factorfactor: initial work

Fixes #13.

character.go

@@ -28,6 +28,8 @@ type AffinityDetail struct {
 
 // Conversation describes a lobby conversation.
 type Conversation struct {
+	// ID is the conversation ID.
+	ID int32 `json:"id"`
 	// CharacterID is the ID of the character who has the conversation as
 	// a gallery entry.
 	CharacterID CharacterID `json:"chara_id"`

cmd/factorfactor/factor.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"log/slog"
+
+	"git.sunturtle.xyz/zephyr/horse"
+	"git.sunturtle.xyz/zephyr/horse/umadump/ism"
+)
+
+// For each gain type from inspiration (stats, caps, aptitudes, skills):
+// find all activated sparks that can give that gain type.
+// Then, find all subsets of effect groups among those sparks
+// that have effects summing to those observed
+// (or more if the .end_info result is maxed),
+// with the restriction that one comes from each spark.
+// Deduplicate permutations.
+// Lastly, find the intersection of possible effects from sparks that appear
+// multiple times.
+//
+// To some extent, we rely on there being no sparks with the random stats effect type,
+// although we also don't know the distribution of stats from overcapped skill hints.
+
+type target struct {
+	spark  *horse.Spark
+	group  int
+	effect horse.SparkEffect
+}
+
+func skilltargets(sparks []horse.Spark) map[horse.SkillID]map[horse.SparkID][]target {
+	r := make(map[horse.SkillID]map[horse.SparkID][]target)
+	for i, sp := range sparks {
+		for j, g := range sp.Effects {
+			for _, e := range g {
+				if e.Target != horse.SparkSkillHint {
+					continue
+				}
+				if r[horse.SkillID(e.Value1)] == nil {
+					r[horse.SkillID(e.Value1)] = make(map[horse.SparkID][]target)
+				}
+				r[horse.SkillID(e.Value1)][sp.ID] = append(r[horse.SkillID(e.Value1)][sp.ID], target{&sparks[i], j, e})
+			}
+		}
+	}
+	return r
+}
+
+func resolveSkills(tab tables, career *ism.WorkIdleSingleMode)
+
+// skillsparks appends all activated sparks that can yield a given skill to r.
+// It assumes that no spark can give multiple skills.
+func skillsparks(tab tables, sparks []ism.Factor, id horse.SkillID, r []*horse.Spark) []*horse.Spark {
+	for _, f := range sparks {
+		sp := tab.sparks[f.FactorID]
+		if sp == nil {
+			// ATM we do generally exclude Carnival Bonus from spark info.
+			// Better to check.
+			slog.Warn("skipped spark", slog.Int("id", int(f.FactorID)))
+			continue
+		}
+		if sparkHasSkill(sp, id) {
+			r = append(r, sp)
+		}
+	}
+	return r
+}
+
+func sparkHasSkill(sp *horse.Spark, id horse.SkillID) bool {
+	for _, g := range sp.Effects {
+		for _, e := range g {
+			if e.Target != horse.SparkSkillHint {
+				continue
+			}
+			return id == horse.SkillID(e.Value1)
+		}
+	}
+	return false
+}

cmd/factorfactor/main.go

@@ -0,0 +1,111 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log/slog"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"slices"
+
+	"git.sunturtle.xyz/zephyr/horse/mdb"
+	"git.sunturtle.xyz/zephyr/horse/umadump/ism"
+	"golang.org/x/sync/errgroup"
+	"zombiezen.com/go/sqlite"
+	"zombiezen.com/go/sqlite/sqlitex"
+)
+
+func main() {
+	var (
+		mdbf  string
+		dirs  []string
+		files []string
+	)
+	flag.StringVar(&mdbf, "-mdb", "", "`path` to master.mdb")
+	flag.Func("d", "idle_single_mode `dir`ectory (may be specified multiple times)", func(s string) error {
+		dirs = append(dirs, s)
+		return nil
+	})
+	flag.Parse()
+
+	files = slices.Clone(flag.Args())
+	for _, dir := range dirs {
+		ds, err := os.ReadDir(dir)
+		if err != nil {
+			slog.Error("getting files in directory", slog.String("dir", dir), slog.Any("err", err))
+			os.Exit(1)
+		}
+		for _, d := range ds {
+			if d.IsDir() {
+				continue
+			}
+			files = append(files, filepath.Join(dir, d.Name()))
+		}
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
+	go func() {
+		<-ctx.Done()
+		stop()
+	}()
+
+	db, err := sqlitex.NewPool(mdbf, sqlitex.PoolOptions{Flags: sqlite.OpenReadOnly})
+	if err != nil {
+		slog.Error("mdb", slog.Any("err", err))
+		os.Exit(1)
+	}
+
+	slog.Info("load skills")
+	skills, err := mdb.Skills(ctx, db)
+	if err != nil {
+		slog.Error("skills", slog.Any("err", err))
+		os.Exit(1)
+	}
+	slog.Info("load sparks")
+	sparks, err := mdb.Sparks(ctx, db)
+	if err != nil {
+		slog.Error("sparks", slog.Any("err", err))
+		os.Exit(1)
+	}
+	slog.Info("load umas")
+	umas, err := mdb.Umas(ctx, db)
+	if err != nil {
+		slog.Error("umas", slog.Any("err", err))
+		os.Exit(1)
+	}
+	slog.Info("mdb",
+		slog.Int("sparks", len(sparks)),
+		slog.Int("skills", len(skills)),
+		slog.Int("umas", len(umas)),
+	)
+	tab := makeTables(skills, sparks, umas)
+
+	g, ctx := errgroup.WithContext(ctx)
+	g.SetLimit(64)
+	for _, file := range files {
+		g.Go(func() error {
+			return dofile(ctx, file)
+		})
+	}
+	if err := g.Wait(); err != nil {
+		slog.Error("process", slog.Any("err", err))
+		os.Exit(1)
+	}
+}
+
+func dofile(ctx context.Context, file string) error {
+	f, err := os.Open(file)
+	if err != nil {
+		return err
+	}
+	var career ism.WorkIdleSingleMode
+	d := json.NewDecoder(f)
+	d.DisallowUnknownFields()
+	if err := d.Decode(&career); err != nil {
+		return fmt.Errorf("%s: %w", file, err)
+	}
+
+}

cmd/factorfactor/mdb.go

@@ -0,0 +1,37 @@
+package main
+
+import "git.sunturtle.xyz/zephyr/horse"
+
+type tables struct {
+	skills map[horse.SkillID]*horse.Skill
+	groups map[horse.SkillGroupID]map[int8]*horse.Skill
+	sparks map[horse.SparkID]*horse.Spark
+	umas   map[horse.UmaID]*horse.Uma
+}
+
+func makeTables(skills []horse.Skill, sparks []horse.Spark, umas []horse.Uma) tables {
+	tab := tables{
+		skills: make(map[horse.SkillID]*horse.Skill, len(skills)),
+		groups: make(map[horse.SkillGroupID]map[int8]*horse.Skill, len(skills)/2),
+		sparks: make(map[horse.SparkID]*horse.Spark, len(sparks)),
+		umas:   make(map[horse.UmaID]*horse.Uma, len(umas)),
+	}
+	for i, sk := range skills {
+		tab.skills[sk.ID] = &skills[i]
+		if tab.groups[sk.Group] == nil {
+			tab.groups[sk.Group] = make(map[int8]*horse.Skill, 4)
+		}
+		// Only add the skill to the groups table if they're rare, the base
+		// version of the common skill, or there isn't anything else there.
+		if sk.Rarity == 2 || sk.GroupRate == 1 || tab.groups[sk.Group][sk.Rarity] == nil {
+			tab.groups[sk.Group][sk.Rarity] = &skills[i]
+		}
+	}
+	for i, sp := range sparks {
+		tab.sparks[sp.ID] = &sparks[i]
+	}
+	for i, u := range umas {
+		tab.umas[u.ID] = &umas[i]
+	}
+	return tab
+}

mdb/character.go

@@ -89,13 +89,14 @@ func Umas(ctx context.Context, db *sqlitex.Pool) ([]horse.Uma, error) {
 func Conversations(ctx context.Context, db *sqlitex.Pool) ([]horse.Conversation, error) {
 	return load(ctx, db, make([]horse.Conversation, 0, 1024), 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)),
-			Chara1:        horse.CharacterID(s.ColumnInt(3)),
-			Chara2:        horse.CharacterID(s.ColumnInt(4)),
-			Chara3:        horse.CharacterID(s.ColumnInt(5)),
-			ConditionType: s.ColumnInt(6),
+			ID:            s.ColumnInt32(0),
+			CharacterID:   horse.CharacterID(s.ColumnInt(1)),
+			Number:        s.ColumnInt(2),
+			Location:      horse.LobbyConversationLocationID(s.ColumnInt(3)),
+			Chara1:        horse.CharacterID(s.ColumnInt(4)),
+			Chara2:        horse.CharacterID(s.ColumnInt(5)),
+			Chara3:        horse.CharacterID(s.ColumnInt(6)),
+			ConditionType: s.ColumnInt(7),
 		}
 	})
 }

mdb/character_test.go

@@ -238,12 +238,14 @@ func TestConversations(t *testing.T) {
 	}
 	want := []horse.Conversation{
 		{
+			ID:          1,
 			CharacterID: 1001,
 			Number:      1,
 			Location:    410,
 			Chara1:      1001,
 		},
 		{
+			ID:            2,
 			CharacterID:   1001,
 			Number:        2,
 			Location:      510,
@@ -251,6 +253,7 @@ func TestConversations(t *testing.T) {
 			ConditionType: 1,
 		},
 		{
+			ID:            3,
 			CharacterID:   1001,
 			Number:        3,
 			Location:      310,
@@ -258,6 +261,7 @@ func TestConversations(t *testing.T) {
 			ConditionType: 1,
 		},
 		{
+			ID:            76,
 			CharacterID:   1001,
 			Number:        4,
 			Location:      120,
@@ -266,6 +270,7 @@ func TestConversations(t *testing.T) {
 			ConditionType: 2,
 		},
 		{
+			ID:            77,
 			CharacterID:   1001,
 			Number:        5,
 			Location:      520,
@@ -274,6 +279,7 @@ func TestConversations(t *testing.T) {
 			ConditionType: 3,
 		},
 		{
+			ID:            126,
 			CharacterID:   1001,
 			Number:        6,
 			Location:      430,
@@ -283,12 +289,14 @@ func TestConversations(t *testing.T) {
 			ConditionType: 1,
 		},
 		{
+			ID:          4,
 			CharacterID: 1002,
 			Number:      1,
 			Location:    310,
 			Chara1:      1002,
 		},
 		{
+			ID:            5,
 			CharacterID:   1002,
 			Number:        2,
 			Location:      210,
@@ -296,6 +304,7 @@ func TestConversations(t *testing.T) {
 			ConditionType: 1,
 		},
 		{
+			ID:            6,
 			CharacterID:   1002,
 			Number:        3,
 			Location:      110,
@@ -303,6 +312,7 @@ func TestConversations(t *testing.T) {
 			ConditionType: 1,
 		},
 		{
+			ID:            78,
 			CharacterID:   1002,
 			Number:        4,
 			Location:      520,
@@ -311,6 +321,7 @@ func TestConversations(t *testing.T) {
 			ConditionType: 3,
 		},
 		{
+			ID:            79,
 			CharacterID:   1002,
 			Number:        5,
 			Location:      220,

mdb/skill.go

@@ -18,6 +18,8 @@ var (
 	skillGroupSQL string
 	//go:embed sql/skill.sql
 	skillSQL string
+	//go:embed sql/skill-group-skills.sql
+	skillGroupSkillsSQL string
 )
 
 // SkillGroups retrieves all skill groups.
@@ -35,84 +37,128 @@ func SkillGroups(ctx context.Context, db *sqlitex.Pool) ([]horse.SkillGroup, err
 
 // Skills retrieves all skills.
 func Skills(ctx context.Context, db *sqlitex.Pool) ([]horse.Skill, error) {
-	return load(ctx, db, nil, 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
-			Tags:        parseTags(s.ColumnText(54)),
-			SPCost:      s.ColumnInt(49),
-			IconID:      s.ColumnInt(53),
+	// We don't use func load here because we have multiple queries to run.
+	conn, err := db.Take(ctx)
+	defer db.Put(conn)
+	if err != nil {
+		return nil, err
+	}
+	var sk []horse.Skill
+	{
+		stmt := conn.Prep(skillSQL)
+		defer stmt.Reset()
+		for {
+			ok, err := stmt.Step()
+			if err != nil {
+				return nil, err
+			}
+			if !ok {
+				break
+			}
+			s := horse.Skill{
+				ID:          horse.SkillID(stmt.ColumnInt(0)),
+				Name:        stmt.ColumnText(1),
+				Description: stmt.ColumnText(2),
+				GroupSkills: make([]horse.GroupSkill, 0, 3),
+				Group:       horse.SkillGroupID(stmt.ColumnInt32(3)),
+				Rarity:      int8(stmt.ColumnInt(5)),
+				GroupRate:   int8(stmt.ColumnInt(6)),
+				GradeValue:  stmt.ColumnInt32(7),
+				WitCheck:    stmt.ColumnBool(8),
+				Activations: trimActivations([]horse.Activation{
+					{
+						Precondition: stmt.ColumnText(9),
+						Condition:    stmt.ColumnText(10),
+						Duration:     horse.TenThousandths(stmt.ColumnInt(11)),
+						DurScale:     horse.DurScale(stmt.ColumnInt(12)),
+						Cooldown:     horse.TenThousandths(stmt.ColumnInt(13)),
+						Abilities: trimAbilities([]horse.Ability{
+							{
+								Type:        horse.AbilityType(stmt.ColumnInt(14)),
+								ValueUsage:  horse.AbilityValueUsage(stmt.ColumnInt(15)),
+								Value:       horse.TenThousandths(stmt.ColumnInt(16)),
+								Target:      horse.AbilityTarget(stmt.ColumnInt(17)),
+								TargetValue: stmt.ColumnInt32(18),
+							},
+							{
+								Type:        horse.AbilityType(stmt.ColumnInt(19)),
+								ValueUsage:  horse.AbilityValueUsage(stmt.ColumnInt(20)),
+								Value:       horse.TenThousandths(stmt.ColumnInt(21)),
+								Target:      horse.AbilityTarget(stmt.ColumnInt(22)),
+								TargetValue: stmt.ColumnInt32(23),
+							},
+							{
+								Type:        horse.AbilityType(stmt.ColumnInt(24)),
+								ValueUsage:  horse.AbilityValueUsage(stmt.ColumnInt(25)),
+								Value:       horse.TenThousandths(stmt.ColumnInt(26)),
+								Target:      horse.AbilityTarget(stmt.ColumnInt(27)),
+								TargetValue: stmt.ColumnInt32(28),
+							},
+						}),
+					},
+					{
+						Precondition: stmt.ColumnText(29),
+						Condition:    stmt.ColumnText(30),
+						Duration:     horse.TenThousandths(stmt.ColumnInt(31)),
+						DurScale:     horse.DurScale(stmt.ColumnInt(32)),
+						Cooldown:     horse.TenThousandths(stmt.ColumnInt(33)),
+						Abilities: trimAbilities([]horse.Ability{
+							{
+								Type:        horse.AbilityType(stmt.ColumnInt(34)),
+								ValueUsage:  horse.AbilityValueUsage(stmt.ColumnInt(35)),
+								Value:       horse.TenThousandths(stmt.ColumnInt(36)),
+								Target:      horse.AbilityTarget(stmt.ColumnInt(37)),
+								TargetValue: stmt.ColumnInt32(38),
+							},
+							{
+								Type:        horse.AbilityType(stmt.ColumnInt(39)),
+								ValueUsage:  horse.AbilityValueUsage(stmt.ColumnInt(40)),
+								Value:       horse.TenThousandths(stmt.ColumnInt(41)),
+								Target:      horse.AbilityTarget(stmt.ColumnInt(42)),
+								TargetValue: stmt.ColumnInt32(43),
+							},
+							{
+								Type:        horse.AbilityType(stmt.ColumnInt(44)),
+								ValueUsage:  horse.AbilityValueUsage(stmt.ColumnInt(45)),
+								Value:       horse.TenThousandths(stmt.ColumnInt(46)),
+								Target:      horse.AbilityTarget(stmt.ColumnInt(47)),
+								TargetValue: stmt.ColumnInt32(48),
+							},
+						}),
+					},
+				}),
+				UniqueOwner: stmt.ColumnText(52), // TODO(zeph): should be id, not name
+				Tags:        parseTags(stmt.ColumnText(54)),
+				SPCost:      stmt.ColumnInt(49),
+				IconID:      stmt.ColumnInt(53),
+			}
+			sk = append(sk, s)
 		}
-	})
+	}
+	stmt := conn.Prep(skillGroupSkillsSQL)
+	defer stmt.Reset()
+	cur := sk
+	for {
+		ok, err := stmt.Step()
+		if err != nil {
+			return nil, err
+		}
+		if !ok {
+			break
+		}
+		// We sort skills by ID first, so we can add group skills in a single pass.
+		id := stmt.ColumnInt(0)
+		for len(cur) != 0 && cur[0].ID != horse.SkillID(id) {
+			cur = cur[1:]
+		}
+		g := horse.GroupSkill{
+			ID:        horse.SkillID(stmt.ColumnInt(1)),
+			GroupRate: int8(stmt.ColumnInt(2)),
+			Rarity:    int8(stmt.ColumnInt(3)),
+		}
+		cur[0].GroupSkills = append(cur[0].GroupSkills, g)
+	}
+	return sk, nil
 }
 
 func parseTags(s string) []uint16 {

mdb/skill_test.go

@@ -49,11 +49,16 @@ func TestSkills(t *testing.T) {
 			ID:          10351,
 			Name:        "V Is for Victory!",
 			Description: "Moderately increase velocity with winning ambition when positioned toward the front on the final straight after engaging in a challenge on the final corner or later.",
-			Group:       1035,
-			Rarity:      3,
-			GroupRate:   1,
-			GradeValue:  240,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 100351, GroupRate: 1, Rarity: 4},
+				{ID: 10351, GroupRate: 1, Rarity: 3},
+				{ID: 900351, GroupRate: 2, Rarity: 1},
+			},
+			Group:      1035,
+			Rarity:     3,
+			GroupRate:  1,
+			GradeValue: 240,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "is_finalcorner==1&blocked_side_continuetime>=2",
@@ -81,11 +86,15 @@ func TestSkills(t *testing.T) {
 			ID:          100011,
 			Name:        "Shooting Star",
 			Description: "Ride the momentum to increase velocity and very slightly increase acceleration after passing another runner toward the front late-race.",
-			Group:       10001,
-			Rarity:      5,
-			GroupRate:   1,
-			GradeValue:  340,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 100011, GroupRate: 1, Rarity: 5},
+				{ID: 900011, GroupRate: 2, Rarity: 1},
+			},
+			Group:      10001,
+			Rarity:     5,
+			GroupRate:  1,
+			GradeValue: 340,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -120,11 +129,16 @@ func TestSkills(t *testing.T) {
 			ID:          100351,
 			Name:        "Our Ticket to Win!",
 			Description: "Increase velocity with winning ambition when positioned toward the front on the final straight after engaging in a challenge on the final corner or later.",
-			Group:       10035,
-			Rarity:      4,
-			GroupRate:   1,
-			GradeValue:  340,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 100351, GroupRate: 1, Rarity: 4},
+				{ID: 10351, GroupRate: 1, Rarity: 3},
+				{ID: 900351, GroupRate: 2, Rarity: 1},
+			},
+			Group:      10035,
+			Rarity:     4,
+			GroupRate:  1,
+			GradeValue: 340,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "is_finalcorner==1&blocked_side_continuetime>=2",
@@ -152,11 +166,15 @@ func TestSkills(t *testing.T) {
 			ID:          110241,
 			Name:        "Flowery☆Maneuver",
 			Description: "Increase velocity when passing another runner toward the front on the final corner. If passing toward the back, increase acceleration instead.",
-			Group:       11024,
-			Rarity:      5,
-			GroupRate:   1,
-			GradeValue:  340,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 110241, GroupRate: 1, Rarity: 5},
+				{ID: 910241, GroupRate: 2, Rarity: 1},
+			},
+			Group:      11024,
+			Rarity:     5,
+			GroupRate:  1,
+			GradeValue: 340,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -200,11 +218,17 @@ func TestSkills(t *testing.T) {
 			ID:          200011,
 			Name:        "Right-Handed ◎",
 			Description: "Increase performance on right-handed tracks.",
-			Group:       20001,
-			Rarity:      1,
-			GroupRate:   2,
-			GradeValue:  174,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200013, GroupRate: -1, Rarity: 1},
+				{ID: 200012, GroupRate: 1, Rarity: 1},
+				{ID: 200011, GroupRate: 2, Rarity: 1},
+				{ID: 200014, GroupRate: 3, Rarity: 2},
+			},
+			Group:      20001,
+			Rarity:     1,
+			GroupRate:  2,
+			GradeValue: 174,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -231,11 +255,17 @@ func TestSkills(t *testing.T) {
 			ID:          200012,
 			Name:        "Right-Handed ○",
 			Description: "Moderately increase performance on right-handed tracks.",
-			Group:       20001,
-			Rarity:      1,
-			GroupRate:   1,
-			GradeValue:  129,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200013, GroupRate: -1, Rarity: 1},
+				{ID: 200012, GroupRate: 1, Rarity: 1},
+				{ID: 200011, GroupRate: 2, Rarity: 1},
+				{ID: 200014, GroupRate: 3, Rarity: 2},
+			},
+			Group:      20001,
+			Rarity:     1,
+			GroupRate:  1,
+			GradeValue: 129,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -262,11 +292,17 @@ func TestSkills(t *testing.T) {
 			ID:          200013,
 			Name:        "Right-Handed ×",
 			Description: "Moderately decrease performance on right-handed tracks.",
-			Group:       20001,
-			Rarity:      1,
-			GroupRate:   -1,
-			GradeValue:  -129,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200013, GroupRate: -1, Rarity: 1},
+				{ID: 200012, GroupRate: 1, Rarity: 1},
+				{ID: 200011, GroupRate: 2, Rarity: 1},
+				{ID: 200014, GroupRate: 3, Rarity: 2},
+			},
+			Group:      20001,
+			Rarity:     1,
+			GroupRate:  -1,
+			GradeValue: -129,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -293,11 +329,17 @@ func TestSkills(t *testing.T) {
 			ID:          200014,
 			Name:        "Right-Handed Demon",
 			Description: "Increase proficiency in right-handed tracks, increasing Speed and Power.",
-			Group:       20001,
-			Rarity:      2,
-			GroupRate:   3,
-			GradeValue:  461,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200013, GroupRate: -1, Rarity: 1},
+				{ID: 200012, GroupRate: 1, Rarity: 1},
+				{ID: 200011, GroupRate: 2, Rarity: 1},
+				{ID: 200014, GroupRate: 3, Rarity: 2},
+			},
+			Group:      20001,
+			Rarity:     2,
+			GroupRate:  3,
+			GradeValue: 461,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -331,11 +373,16 @@ func TestSkills(t *testing.T) {
 			ID:          200021,
 			Name:        "Left-Handed ◎",
 			Description: "Increase performance on left-handed tracks.",
-			Group:       20002,
-			Rarity:      1,
-			GroupRate:   2,
-			GradeValue:  174,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200023, GroupRate: -1, Rarity: 1},
+				{ID: 200022, GroupRate: 1, Rarity: 1},
+				{ID: 200021, GroupRate: 2, Rarity: 1},
+			},
+			Group:      20002,
+			Rarity:     1,
+			GroupRate:  2,
+			GradeValue: 174,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -362,11 +409,16 @@ func TestSkills(t *testing.T) {
 			ID:          200022,
 			Name:        "Left-Handed ○",
 			Description: "Moderately increase performance on left-handed tracks.",
-			Group:       20002,
-			Rarity:      1,
-			GroupRate:   1,
-			GradeValue:  129,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200023, GroupRate: -1, Rarity: 1},
+				{ID: 200022, GroupRate: 1, Rarity: 1},
+				{ID: 200021, GroupRate: 2, Rarity: 1},
+			},
+			Group:      20002,
+			Rarity:     1,
+			GroupRate:  1,
+			GradeValue: 129,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -393,11 +445,16 @@ func TestSkills(t *testing.T) {
 			ID:          200023,
 			Name:        "Left-Handed ×",
 			Description: "Moderately decrease performance on left-handed tracks.",
-			Group:       20002,
-			Rarity:      1,
-			GroupRate:   -1,
-			GradeValue:  -129,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200023, GroupRate: -1, Rarity: 1},
+				{ID: 200022, GroupRate: 1, Rarity: 1},
+				{ID: 200021, GroupRate: 2, Rarity: 1},
+			},
+			Group:      20002,
+			Rarity:     1,
+			GroupRate:  -1,
+			GradeValue: -129,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -424,11 +481,15 @@ func TestSkills(t *testing.T) {
 			ID:          200361,
 			Name:        "Beeline Burst",
 			Description: "Increase velocity on a straight.",
-			Group:       20036,
-			Rarity:      2,
-			GroupRate:   2,
-			GradeValue:  508,
-			WitCheck:    true,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200362, GroupRate: 1, Rarity: 1},
+				{ID: 200361, GroupRate: 2, Rarity: 2},
+			},
+			Group:      20036,
+			Rarity:     2,
+			GroupRate:  2,
+			GradeValue: 508,
+			WitCheck:   true,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -455,11 +516,15 @@ func TestSkills(t *testing.T) {
 			ID:          200362,
 			Name:        "Straightaway Adept",
 			Description: "Slightly increase velocity on a straight.",
-			Group:       20036,
-			Rarity:      1,
-			GroupRate:   1,
-			GradeValue:  217,
-			WitCheck:    true,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200362, GroupRate: 1, Rarity: 1},
+				{ID: 200361, GroupRate: 2, Rarity: 2},
+			},
+			Group:      20036,
+			Rarity:     1,
+			GroupRate:  1,
+			GradeValue: 217,
+			WitCheck:   true,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -486,11 +551,14 @@ func TestSkills(t *testing.T) {
 			ID:          200831,
 			Name:        "Subdued Front Runners",
 			Description: "Slightly increase fatigue for front runners early-race.",
-			Group:       20083,
-			Rarity:      1,
-			GroupRate:   1,
-			GradeValue:  217,
-			WitCheck:    true,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 200831, GroupRate: 1, Rarity: 1},
+			},
+			Group:      20083,
+			Rarity:     1,
+			GroupRate:  1,
+			GradeValue: 217,
+			WitCheck:   true,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -517,11 +585,14 @@ func TestSkills(t *testing.T) {
 			ID:          201801,
 			Name:        "♡ 3D Nail Art",
 			Description: "Moderately decrease performance on firm ground.",
-			Group:       20180,
-			Rarity:      1,
-			GroupRate:   -1,
-			GradeValue:  -129,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 201801, GroupRate: -1, Rarity: 1},
+			},
+			Group:      20180,
+			Rarity:     1,
+			GroupRate:  -1,
+			GradeValue: -129,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -548,11 +619,14 @@ func TestSkills(t *testing.T) {
 			ID:          300011,
 			Name:        "Unquenched Thirst",
 			Description: "Moderately increase performance with the desire to race.",
-			Group:       30001,
-			Rarity:      1,
-			GroupRate:   1,
-			GradeValue:  0,
-			WitCheck:    false,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 300011, GroupRate: 1, Rarity: 1},
+			},
+			Group:      30001,
+			Rarity:     1,
+			GroupRate:  1,
+			GradeValue: 0,
+			WitCheck:   false,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -579,11 +653,15 @@ func TestSkills(t *testing.T) {
 			ID:          900011,
 			Name:        "Shooting Star",
 			Description: "Slightly increase velocity and very minimally increase acceleration after passing another runner toward the front late-race.",
-			Group:       10001,
-			Rarity:      1,
-			GroupRate:   2,
-			GradeValue:  180,
-			WitCheck:    true,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 100011, GroupRate: 1, Rarity: 5},
+				{ID: 900011, GroupRate: 2, Rarity: 1},
+			},
+			Group:      10001,
+			Rarity:     1,
+			GroupRate:  2,
+			GradeValue: 180,
+			WitCheck:   true,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",
@@ -618,11 +696,16 @@ func TestSkills(t *testing.T) {
 			ID:          900351,
 			Name:        "Our Ticket to Win!",
 			Description: "Slightly increase velocity when positioned toward the front on the final straight after engaging in a challenge on the final corner or later.",
-			Group:       10035,
-			Rarity:      1,
-			GroupRate:   2,
-			GradeValue:  180,
-			WitCheck:    true,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 100351, GroupRate: 1, Rarity: 4},
+				{ID: 10351, GroupRate: 1, Rarity: 3},
+				{ID: 900351, GroupRate: 2, Rarity: 1},
+			},
+			Group:      10035,
+			Rarity:     1,
+			GroupRate:  2,
+			GradeValue: 180,
+			WitCheck:   true,
 			Activations: []horse.Activation{
 				{
 					Precondition: "is_finalcorner==1&blocked_side_continuetime>=2",
@@ -650,11 +733,15 @@ func TestSkills(t *testing.T) {
 			ID:          910241,
 			Name:        "Flowery☆Maneuver",
 			Description: "Slightly increase velocity when passing another runner toward the front on the final corner. If passing toward the back, slightly increase acceleration instead.",
-			Group:       11024,
-			Rarity:      1,
-			GroupRate:   2,
-			GradeValue:  180,
-			WitCheck:    true,
+			GroupSkills: []horse.GroupSkill{
+				{ID: 110241, GroupRate: 1, Rarity: 5},
+				{ID: 910241, GroupRate: 2, Rarity: 1},
+			},
+			Group:      11024,
+			Rarity:     1,
+			GroupRate:  2,
+			GradeValue: 180,
+			WitCheck:   true,
 			Activations: []horse.Activation{
 				{
 					Precondition: "",

mdb/sql/conversation.sql

@@ -1,4 +1,5 @@
 SELECT
+	id,
 	gallery_chara_id,
     disp_order,
 	pos_id,

mdb/sql/skill-group-skills.sql

@@ -0,0 +1,43 @@
+WITH g AS (
+	SELECT
+		l.id AS l,
+		r.id AS r,
+		r.group_rate,
+		r.rarity
+	FROM skill_data l
+		JOIN skill_data r ON l.group_id = r.group_id
+	
+	UNION ALL
+
+	SELECT
+		s.id AS l,
+		i.id AS r,
+		i.group_rate,
+		i.rarity
+	FROM skill_data s
+		JOIN skill_data i ON s.id IN (i.unique_skill_id_1, i.unique_skill_id_2)
+	
+	UNION ALL
+
+	SELECT
+		s.id AS l,
+		i.id AS r,
+		i.group_rate,
+		i.rarity
+	FROM skill_data s
+		JOIN skill_data i ON i.id IN (s.unique_skill_id_1, s.unique_skill_id_2)
+
+	UNION ALL
+
+	SELECT
+		l.id AS l,
+		r.id AS r,
+		r.group_rate,
+		r.rarity
+	FROM skill_data i
+		JOIN skill_data l ON l.id IN (i.unique_skill_id_1, i.unique_skill_id_2)
+		JOIN skill_data r ON r.id IN (i.unique_skill_id_1, i.unique_skill_id_2)
+	WHERE l.id != r.id
+)
+SELECT * FROM g
+ORDER BY l, group_rate, rarity DESC

skill.go

@@ -30,6 +30,7 @@ type Skill struct {
 	ID          SkillID      `json:"skill_id"`
 	Name        string       `json:"name"`
 	Description string       `json:"description"`
+	GroupSkills []GroupSkill `json:"group_skills"`
 	Group       SkillGroupID `json:"group"`
 	Rarity      int8         `json:"rarity"`
 	GroupRate   int8         `json:"group_rate"`
@@ -42,6 +43,12 @@ type Skill struct {
 	IconID      int          `json:"icon_id"`
 }
 
+type GroupSkill struct {
+	ID        SkillID `json:"skill_id"`
+	GroupRate int8    `json:"group_rate"`
+	Rarity    int8    `json:"rarity"`
+}
+
 // Activation is the parameters controlling when a skill activates.
 type Activation struct {
 	Precondition string         `json:"precondition,omitzero"`

zenno/src/lib/data/convo.ts

@@ -49,11 +49,16 @@ export function convoCharas(c: Conversation): number[] {
 
 export function requiredCharas(c: Conversation): number[] {
 	switch (c.condition_type) {
-		case Required.None: return []
-		case Required.All: return convoCharas(c);
-		case Required.Chara1: return [c.chara_1];
-		case Required.Chara2: return [c.chara_2!];
-		case Required.Chara3: return [c.chara_3!];
+		case Required.None:
+			return [];
+		case Required.All:
+			return convoCharas(c);
+		case Required.Chara1:
+			return [c.chara_1];
+		case Required.Chara2:
+			return [c.chara_2!];
+		case Required.Chara3:
+			return [c.chara_3!];
 	}
 }
 

zenno/src/routes/doc/frbm/+page.svelte

@@ -1143,22 +1143,14 @@
 		>. (This race is why I made it.)
 	</p>
 
-	<Sec h={3} id="jbc-sprint">JBC Sprint (Ooi ver.)</Sec>
-	<p>
-		An even more anti-front track is Ooi 1200 Dirt. This one is actively malicious. Visually, it looks like late race starts on a
-		corner, but the portion before the stretch is a special <i>neither corner nor straight</i> property. That means Angling won't activate,
-		and VPP is delayed (though still within the accel period).
-	</p>
-	<p>
-		Fortunately, JBC Sprint is after summer, which means you should be able to stat diff your opponents. If you are planning to
-		win this race, you may want to prioritize a bit of extra speed training, or take Front Straights/Corners. If MANT, don't be
-		too surprised if you lose a clock or five to a Taiki Shuttle rival.
-	</p>
-	<p>
-		Since the 1 Jul update, the JBC races take place at a randomly selected one of the NAR courses (Ooi, Kawasaki, Funabashi,
-		Morioka) each year. If you're hunting for a completionist title on a front runner, you have the option of just not picking an
-		Ooi JBC Sprint; the others are all Angling tracks.
-	</p>
+	<div id="jbc-sprint" class="hidden target:block">
+		<h3>JBC Sprint</h3>
+		<p>
+			It used to be the case that Oi 1200 Dirt had a strange neither-straight-nor-corner segment at the start of late race so that
+			Angling wouldn't activate. As of the 1 Jul update, the corner is now connected to the final straight, so there is no longer
+			anything remarkable about this track.
+		</p>
+	</div>
 
 	<Sec h={3} id="3k">Kikuka Sho &amp; Tenno Sho (Spring)</Sec>
 	<p>

zenno/src/routes/doc/mdb/+page.svelte

@@ -17,8 +17,107 @@
 		}
 	});
 
+	const raceGroups = [
+		[1, 'Common'],
+		[2, 'Daily Race'],
+		[3, '"Training Practice"'],
+		[4, '"Story Condition"'],
+		[5, '"Team Building"'],
+		[6, 'Practice'],
+		[7, 'Career-Exclusive'],
+		[8, 'Legend Race'],
+		[9, 'Team Trials'],
+		[10, 'Unity Cup Team Race'],
+		[11, "Champions' Meet"],
+		[12, 'Room Match'],
+		[13, '"Challenge Match"'],
+		[14, 'League of Heroes Race'],
+		[61, 'Custom G1'],
+	] as const;
+
+	const raceGrades = [
+		[100, 'G1'],
+		[200, 'G2'],
+		[300, 'G3'],
+		[400, 'OP'],
+		[700, 'Pre-OP'],
+		[800, 'Maiden'],
+		[900, 'Debut'],
+		[999, 'Daily Race or Room Match (?)'],
+		[1000, 'Unity Cup Team Race (?)'],
+	] as const;
+
+	const raceTimes = [
+		[1, 'Morning (unused)'],
+		[2, 'Daytime'],
+		[3, 'Evening'],
+		[4, 'Night'],
+	] as const;
+
+	const raceInitialLanes = [
+		[1, 9, 0.03333333],
+		[2, 0, 0],
+		[3, 14, 0.10333333],
+		[4, 8, 0.03333333],
+	] as const;
+
+	const raceAreas = [
+		[0, 'Hokkaido'],
+		[1, 'Tohoku'],
+		[2, 'Kanto'],
+		[3, 'Western Japan'],
+		[4, 'Kokura'],
+		[5, 'France'],
+		[6, 'America'],
+	] as const;
+
+	const raceLoops = [
+		[1, 'None'],
+		[2, 'Inner'],
+		[3, 'Outer'],
+		[4, 'Outer→Inner'],
+	] as const;
+
+	const raceRotations = [
+		[1, 'Right'],
+		[2, 'Left'],
+		[3, 'Rightward Stretch (unused)'],
+		[4, 'Leftward Stretch'],
+	] as const;
+
+	const raceCourseThresholds = [
+		[1, 1, 0],
+		[2, 2, 0],
+		[3, 3, 0],
+		[4, 4, 0],
+		[5, 5, 0],
+		[6, 1, 2],
+		[7, 2, 3],
+		[8, 2, 4],
+		[9, 3, 5],
+		[10, 2, 5],
+		[11, 4, 5],
+	] as const;
+
+	const raceSaddleTypes = [
+		[0, 'Special'],
+		[1, 'G3'],
+		[2, 'G2'],
+		[3, 'G1'],
+	] as const;
+
+	const racePermissions = [
+		[1, 'Junior'],
+		[2, 'Classic'],
+		[3, 'Classic and Senior'],
+		[4, 'Senior'],
+		[5, 'Finale'],
+	] as const;
+
 	const skills = $derived({
 		rickey: skillMap.get(100981),
+		right1: skillMap.get(200012),
+		left1: skillMap.get(200022),
 		fall2: skillMap.get(200191),
 		fall1: skillMap.get(200192),
 		fallX: skillMap.get(200193),
@@ -299,6 +398,10 @@
 			in-game shows a "Connecting..." indicator while it loads, it probably isn't in the mdb. Notably, this includes everything
 			related to career event outcomes. (Event information on sites like GameTora and GameWith are massive crowd-sourced efforts.)
 		</p>
+		<p>Since I see this question about weekly, allow me to reiterate.</p>
+		<p class="text-4xl font-bold">
+			Support card event outcomes are not in master.mdb or any other locally stored file. Not even the list of possible skills.
+		</p>
 		<p>
 			This document is oriented toward programmers with understanding of SQL databases. Mentions of <Mono>Gallop::</Mono> are references
 			to types visible in decompilations of the game, but no C# knowledge is needed.
@@ -330,6 +433,363 @@
 		>, but a few categories that have useful strings are missing from there.
 	</p>
 
+	<Sec h={2} id="race">Races</Sec>
+	<p>First, some terminology, as the game uses it internally. (Some UI phrasing disagrees.)</p>
+	<p>
+		A <i>race</i> is an organized running competition, typically held annually. A <i>race instance</i> is a single holding of a
+		race at a specific date and time; this includes special race instances like Team Trials races, Aim for the Stars races,
+		&amp;c. Race instances are held on a given <i>race course</i>, which is a fixed-length segment of a physical location called a
+		<i>race track</i>. A <i>win saddle</i> is a given horse's victory of a race or a specific group of races, e.g. Classic Triple Crown
+		or Dual Grand Prix. This section will cover races, race instances, race tracks, race courses, and win saddles.
+	</p>
+	<p>
+		<Mono>text_data</Mono> categories relevant to races include:
+	</p>
+	<ul class="ml-4 list-disc pb-4">
+		<li>32 and 33 are both race names, the latter for jikkyo (the announcer's lines).</li>
+		<li>
+			28 is race instance names. 29 is abbreviated race instance names, e.g. <Mono>Mile Ch.</Mono> instead of <Mono
+				>Mile Championship</Mono
+			>.
+		</li>
+		<li>
+			31 and 34 are race track full names, the former for jikkyo, e.g. <Mono>Kyoto Racecourse</Mono>. 35 is race track names
+			without "Racecourse".
+		</li>
+		<li>111 is win saddle names.</li>
+	</ul>
+
+	<Sec h={3} id="race-race">Race Info</Sec>
+	<p>
+		Races are defined in <Mono>race</Mono>, which is quite a direct name innit.
+	</p>
+	<ul class="ml-4 list-disc pb-4">
+		<li>
+			Race ID is just <Mono>id</Mono>.
+		</li>
+		<li>
+			<Mono>group</Mono> is the game situation where the race occurs.
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">Group</th>
+						<th scope="col" class="px-2">Meaning</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceGroups as [id, name] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{name}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+		</li>
+		<li>
+			<Mono>grade</Mono> defines the race grade.
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">Grade ID</th>
+						<th scope="col" class="px-2">Meaning</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceGrades as [id, name] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{name}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+		</li>
+		<li><Mono>course_set</Mono> gives the <a href="#race-course">race course</a> where the race occurs.</li>
+		<li><Mono>thumbnail_id</Mono> is the resource ID of the race's thumbnail image.</li>
+		<li><Mono>entry_num</Mono> is the maximum number of horses that can run the race.</li>
+	</ul>
+	<p>
+		Some races are ostensibly defined twice to account for variant races run during some characters' careers, e.g. Maruzensky's
+		five opponent Spring Stakes, McQueen/Ryan/Rice's Kyoto Takarazuka Kinen, &amp;c.
+	</p>
+
+	<Sec h={3} id="race-instances">Race Instances</Sec>
+	<p>
+		The table is <Mono>race_instance</Mono>.
+	</p>
+	<ul class="ml-4 list-disc pb-4">
+		<li><Mono>id</Mono> is the race instance ID.</li>
+		<li><Mono>race_id</Mono> joins with <Mono>race.id</Mono>.</li>
+		<li>
+			<Mono>npc_group_id</Mono> should define the NPC racers allowed to appear in the race instance, although I haven't looked into
+			it.
+		</li>
+		<li>
+			<Mono>date</Mono> gives the month and day-of-month when the race instance occurs, expressed as M&times;100+d &ndash; 1 Jan is
+			101 and 31 Dec is 1231. This appears to decide the season that the race instance occurs in and thus the applicable green skill.
+			E.g., we can see in career that Challenge Cup is offered on the Early December turn, but its race instance has a <Mono
+				>date</Mono
+			> of 1130 (i.e. 30 Nov), so it is a fall rather than winter race. All races occur in 2019.
+		</li>
+		<li>
+			<Mono>time</Mono> is the time of day that the race instance is held.
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">Time</th>
+						<th scope="col" class="px-2">Meaning</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceTimes as [id, name] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{name}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+		</li>
+		<li>
+			<Mono>clock_time</Mono> has a value of 1605 for one race and is otherwise always 0. It might be a specific hour and minute that
+			a race instance occurs, but I'm not sure why that would ever matter.
+		</li>
+		<li>
+			<Mono>race_number</Mono> takes every value between -1 and 12, but I couldn't find any explanation for it.
+		</li>
+	</ul>
+	<p>
+		Similarly to races, some race instances are ostensibly defined twice to account for variant races run during some characters'
+		careers.
+	</p>
+
+	<Sec h={3} id="race-track">Race Tracks</Sec>
+	<p>
+		Since race tracks are the physical locations where races are held, there are not many rows in <Mono>race_track</Mono>. Most of
+		its purpose is to define appearance characteristics, but some fields are mechanically relevant.
+	</p>
+	<ul class="ml-4 list-disc pb-4">
+		<li><Mono>id</Mono> is the race track ID.</li>
+		<li>
+			<Mono>initial_lane_type</Mono> describes the starting lane positions of each horse by determining the location and width of the
+			gap between posts.
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">ID</th>
+						<th scope="col" class="px-2">Gap After Gate</th>
+						<th scope="col" class="px-2">Gap Width (CW)</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceInitialLanes as [id, gate, w] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td>{id}</td>
+							<td>{gate}</td>
+							<td>{w}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+			Horses in gates
+			<i>after</i> the Gap After Gate listed in this table have the gap width added to their starting lane.
+			<Mono>initial_lane_type</Mono> is 2 on Oi, Kawasaki, and Funabashi; 3 on Longchamp; 4 on Morioka; and 1 elsewhere. (The race mechanics
+			doc's
+			<a
+				href="https://docs.google.com/document/d/15VzW9W2tXBBTibBRbZ8IVpW6HaMX8H0RP03kq6Az7Xg/edit?tab=t.0#heading=h.ohdxzwro17n5"
+				target="_blank"
+				rel="noopener noreferrer">description of initial lane</a
+			>
+			uses horse index rather than gate number and describes lanes in units of horse lanes rather than course widths.)
+		</li>
+		<li>
+			<Mono>area</Mono> defines the geographic region where the race track exists.
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">ID</th>
+						<th scope="col" class="px-2">Region</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceAreas as [id, name] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{name}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+		</li>
+	</ul>
+
+	<Sec h={3} id="race-course">Race Courses</Sec>
+	<p>
+		Race courses are physical segments of race tracks. They are defined in <Mono>race_course_set</Mono>.
+	</p>
+	<p>
+		Most tracks have one or two turf loops (the "(Inner)" and "(Outer)" or sometimes "(Outer&rarr;Inner)") and one dirt loop. The
+		length of a race course is determined solely by the position of the gates: since the race course is a physical structure with
+		the audience stands in a specific location, and since said audience wants to see the race finish clearly, courses of all
+		lengths end at the same place on the front stretch. The straight opposite the front stretch is called the backstretch. Corners
+		are counted backward from the front stretch in the order 4, 3, 2, 1; all races except Ibis Summer Dash include corners 3 and
+		4, while long and sometimes medium races run corners multiple times. Some courses start on an extra segment of the track which
+		is <i>neither straight nor corner</i> (which means <Mono>straight_random==1</Mono> skills won't fire there).
+	</p>
+	<ul class="ml-4 list-disc pb-4">
+		<li><Mono>id</Mono> gives the race course ID.</li>
+		<li><Mono>race_track_id</Mono> joins with <Mono>race_track.id</Mono>.</li>
+		<li><Mono>distance</Mono> is the race course length in meters.</li>
+		<li><Mono>ground</Mono> is 1 for turf and 2 for dirt.</li>
+		<li>
+			<Mono>inout</Mono> gives the loop for the surface type where the race occurs.
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">ID</th>
+						<th scope="col" class="px-2">Loop</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceLoops as [id, name] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{name}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+		</li>
+		<li>
+			<Mono>turn</Mono> gives the handedness of the track, i.e. the direction from horses to the rail as they round the track's corners.
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">ID</th>
+						<th scope="col" class="px-2">Handedness</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceRotations as [id, name] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{name}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+			Stretch types have no corners and do not activate <Skill skill={skills.right1} /> or <Skill skill={skills.left1} /> or their variants.
+			Niigata 1000 is the only such race course in the game.
+		</li>
+		<li>
+			<Mono>float_lane_max</Mono> gives the <i>initial</i> race course width in units of ten thousandths of course widths. (Confusingly,
+			no race course has a width of 1 course width.) Some race courses have locations where the lane max changes, but these are defined
+			as events and are not in the mdb.
+		</li>
+		<li>
+			<Mono>course_set_status_id</Mono> joins with <Mono>race_course_set_status.course_set_status_id</Mono> to define the stat thresholds.
+			A value of 0 means no thresholds.
+			<table class="table-fixed border text-center">
+				<caption><Mono>race_course_set_status</Mono></caption>
+				<thead>
+					<tr>
+						<th scope="col" class="px-2"><Mono>course_set_status_id</Mono></th>
+						<th scope="col" class="px-2"><Mono>target_status_1</Mono></th>
+						<th scope="col" class="px-2"><Mono>target_status_2</Mono></th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceCourseThresholds as [id, stat1, stat2] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{stat1}</td>
+							<td class="px-2">{stat2}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+			Status of 1 is Speed, 2 is Power, and so on up to 5 for Wit. 0 means no (second) threshold.
+		</li>
+	</ul>
+	<p>
+		Characteristics like straight and corner locations, slopes, lane max changes, &amp;c. are <i>not</i> in the mdb. They are defined
+		as assets instead and must be extracted using special tools.
+	</p>
+
+	<Sec h={3} id="race-saddle">Win Saddles</Sec>
+	<p>
+		<Mono>single_mode_wins_saddle</Mono> defines the awards given to the horse (not the player) for winning a race or specific group
+		of races. These are the medals displayed as important wins for a horse at the end of a career. They are now purely aesthetic, but
+		I am documenting them anyway because I have the notes already since they used to determine affinity.
+	</p>
+	<ul class="ml-4 list-disc pb-4">
+		<li><Mono>id</Mono> is the win saddle ID.</li>
+		<li><Mono>priority</Mono> is the sort order for win saddles.</li>
+		<li>
+			<Mono>group_id</Mono> associates multiple win saddles for the same race, for horses whose careers have special versions of some
+			races.
+		</li>
+		<li>
+			<Mono>win_saddle_type</Mono> is the type of the win saddle, used to determine the color of the medal displayed.
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">ID</th>
+						<th scope="col" class="px-2">Type</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each raceSaddleTypes as [id, name] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{name}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+			Special win saddles are for win saddles requiring multiple wins, e.g. Classic Triple Crown.
+		</li>
+		<li>
+			<Mono>race_instance_id_1</Mono> through <Mono>race_instance_id_8</Mono> define the race instance IDs that must be won to be awarded
+			the win saddle. Columns beyond <Mono>race_instance_id_3</Mono> are unused.
+		</li>
+	</ul>
+
+	<Sec h={3} id="race-program">Single Mode Program</Sec>
+	<p>
+		The table <Mono>single_mode_program</Mono> defines the race instances offered each turn in a career. Confusingly, races that permit
+		both classic and senior year horses are only defined here once.
+	</p>
+	<ul class="ml-4 list-disc pb-4">
+		<li><Mono>race_instance_id</Mono> joins with <Mono>race_instance.id</Mono>.</li>
+		<li>
+			<Mono>race_permission</Mono> gives the career years that offer the race. (More precisely, it gives the age ranges of horses that
+			are permitted to enter.)
+			<table class="table-fixed border text-center">
+				<thead>
+					<tr>
+						<th scope="col" class="px-2">ID</th>
+						<th scope="col" class="px-2">Meaning</th>
+					</tr>
+				</thead>
+				<tbody>
+					{#each racePermissions as [id, name] (id)}
+						<tr class="even:bg-mist-300 dark:even:bg-mist-900">
+							<td class="px-2">{id}</td>
+							<td class="px-2">{name}</td>
+						</tr>
+					{/each}
+				</tbody>
+			</table>
+		</li>
+		<li><Mono>month</Mono> and <Mono>half</Mono> give the turn that the race is held.</li>
+	</ul>
+	<p>
+		I was unable to identify whether any of the columns indicate maiden races, despite the UI restrictions on when they can
+		appear.
+	</p>
+
 	<Sec h={2} id="skills">Skills</Sec>
 	<p>
 		Relevant <Mono>text_data</Mono> categories include 47 for skill names and 48 for skill descriptions. Otherwise, info for skills
@@ -816,6 +1276,9 @@
 		Relevant <Mono>text_data</Mono> categories include 75 for name including variant, 76 for variant alone, 77 for character name. Category
 		151 gives support card effect names, 154 gives effect descriptions, 150 gives unique effect names, and 155 gives unique effect descriptions.
 	</p>
+	<p class="text-4xl font-bold">
+		Support card event outcomes are not in master.mdb or any other locally stored file. Not even the list of possible skills.
+	</p>
 
 	<Sec h={3} id="support_card_data">Support Card Data</Sec>
 	<p>