614 lines
14 KiB
Go
614 lines
14 KiB
Go
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 uma.sql
|
|
var umaSQL 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
|
|
DurScale 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),
|
|
DurScale: stmt.ColumnInt(12),
|
|
Cooldown: stmt.ColumnInt(13),
|
|
Abilities: [3]SkillAbility{
|
|
{
|
|
Type: stmt.ColumnInt(14),
|
|
ValueUsage: stmt.ColumnInt(15),
|
|
Value: stmt.ColumnInt(16),
|
|
Target: stmt.ColumnInt(17),
|
|
TargetValue: stmt.ColumnInt(18),
|
|
},
|
|
{
|
|
Type: stmt.ColumnInt(19),
|
|
ValueUsage: stmt.ColumnInt(20),
|
|
Value: stmt.ColumnInt(21),
|
|
Target: stmt.ColumnInt(22),
|
|
TargetValue: stmt.ColumnInt(23),
|
|
},
|
|
{
|
|
Type: stmt.ColumnInt(24),
|
|
ValueUsage: stmt.ColumnInt(25),
|
|
Value: stmt.ColumnInt(26),
|
|
Target: stmt.ColumnInt(27),
|
|
TargetValue: stmt.ColumnInt(28),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Precondition: stmt.ColumnText(29),
|
|
Condition: stmt.ColumnText(30),
|
|
Duration: stmt.ColumnInt(31),
|
|
DurScale: stmt.ColumnInt(32),
|
|
Cooldown: stmt.ColumnInt(33),
|
|
Abilities: [3]SkillAbility{
|
|
{
|
|
Type: stmt.ColumnInt(34),
|
|
ValueUsage: stmt.ColumnInt(35),
|
|
Value: stmt.ColumnInt(36),
|
|
Target: stmt.ColumnInt(37),
|
|
TargetValue: stmt.ColumnInt(38),
|
|
},
|
|
{
|
|
Type: stmt.ColumnInt(39),
|
|
ValueUsage: stmt.ColumnInt(40),
|
|
Value: stmt.ColumnInt(41),
|
|
Target: stmt.ColumnInt(42),
|
|
TargetValue: stmt.ColumnInt(43),
|
|
},
|
|
{
|
|
Type: stmt.ColumnInt(44),
|
|
ValueUsage: stmt.ColumnInt(45),
|
|
Value: stmt.ColumnInt(46),
|
|
Target: stmt.ColumnInt(47),
|
|
TargetValue: stmt.ColumnInt(48),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
SPCost: stmt.ColumnInt(49),
|
|
InheritID: stmt.ColumnInt(50),
|
|
UniqueOwnerID: stmt.ColumnInt(51),
|
|
UniqueOwner: stmt.ColumnText(52),
|
|
IconID: stmt.ColumnInt(53),
|
|
Index: stmt.ColumnInt(54),
|
|
}
|
|
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
|
|
}
|
|
|
|
type Uma struct {
|
|
ID int
|
|
CharacterID int
|
|
Name string
|
|
Variant string
|
|
CharacterName string
|
|
|
|
Sprint, Mile, Medium, Long int
|
|
Front, Pace, Late, End int
|
|
Turf, Dirt int
|
|
|
|
UniqueID int
|
|
Skill1, Skill2, Skill3 int
|
|
SkillPL2, SkillPL3, SkillPL4, SkillPL5 int
|
|
}
|
|
|
|
func Umas(ctx context.Context, db *sqlitex.Pool) ([]Uma, error) {
|
|
conn, err := db.Take(ctx)
|
|
defer db.Put(conn)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("couldn't get connection for umas: %w", err)
|
|
}
|
|
stmt, _, err := conn.PrepareTransient(umaSQL)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("couldn't prepare statement for umas: %w", err)
|
|
}
|
|
defer stmt.Finalize()
|
|
|
|
var r []Uma
|
|
for {
|
|
ok, err := stmt.Step()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error stepping umas: %w", err)
|
|
}
|
|
if !ok {
|
|
break
|
|
}
|
|
uma := Uma{
|
|
ID: stmt.ColumnInt(0),
|
|
CharacterID: stmt.ColumnInt(1),
|
|
Name: stmt.ColumnText(2),
|
|
Variant: stmt.ColumnText(3),
|
|
CharacterName: stmt.ColumnText(4),
|
|
Sprint: stmt.ColumnInt(5),
|
|
Mile: stmt.ColumnInt(6),
|
|
Medium: stmt.ColumnInt(7),
|
|
Long: stmt.ColumnInt(8),
|
|
Front: stmt.ColumnInt(9),
|
|
Pace: stmt.ColumnInt(10),
|
|
Late: stmt.ColumnInt(11),
|
|
End: stmt.ColumnInt(12),
|
|
Turf: stmt.ColumnInt(13),
|
|
Dirt: stmt.ColumnInt(14),
|
|
UniqueID: stmt.ColumnInt(15),
|
|
Skill1: stmt.ColumnInt(16),
|
|
Skill2: stmt.ColumnInt(17),
|
|
Skill3: stmt.ColumnInt(18),
|
|
SkillPL2: stmt.ColumnInt(19),
|
|
SkillPL3: stmt.ColumnInt(20),
|
|
SkillPL4: stmt.ColumnInt(21),
|
|
SkillPL5: stmt.ColumnInt(22),
|
|
}
|
|
r = append(r, uma)
|
|
}
|
|
return r, nil
|
|
}
|