1009 lines
33 KiB
Go
1009 lines
33 KiB
Go
package replay
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
|
|
"git.sunturtle.xyz/zephyr/horse"
|
|
"git.sunturtle.xyz/zephyr/horse/umadump"
|
|
)
|
|
|
|
type Race struct {
|
|
RaceType RaceType `json:"raceType"`
|
|
IsExistPlayerRace bool `json:"isExistPlayerRace"`
|
|
IsExistGhostRace bool `json:"isExistGhostRace"`
|
|
IsExistFollowRace bool `json:"isExistFollowRace"`
|
|
IsMultiplePlayerRace bool `json:"isMultiplePlayerRace"`
|
|
RandomSeed int32 `json:"randomSeed"`
|
|
SingleRaceProgramID int32 `json:"singleRaceProgramId"`
|
|
OpponentEvaluate int32 `json:"opponentEvaluate"`
|
|
SelfEvaluate int32 `json:"selfEvaluate"`
|
|
SupportCardScoreBonus int32 `json:"supportCardScoreBonus"`
|
|
ScoreCalcTeamID int32 `json:"scoreCalcTeamId"`
|
|
RaceNo int32 `json:"raceNo"`
|
|
RaceCourseSet RaceCourseSet `json:"raceCourseSet"`
|
|
FenceSet struct{} `json:"fenceSet"`
|
|
RaceTrack struct{} `json:"raceTrack"`
|
|
GoalGate int32 `json:"goalGate"`
|
|
GoalGateFlower int32 `json:"goalGateFlower"`
|
|
InitialLaneType InitialLaneType `json:"initialLaneType"`
|
|
RotationCategory Rotation `json:"rotationCategory"`
|
|
ResultBoardConditionType ResultBoardConditionType `json:"resultBoardConditionType"`
|
|
CourseSectionDistance float32 `json:"courseSectionDistance"`
|
|
CourseDistanceType CourseDistanceType `json:"courseDistanceType"`
|
|
CourseFurlongNum int32 `json:"courseFurlongNum"`
|
|
IsHalfGate bool `json:"isHalfGate"`
|
|
IsHorseNumVariationGate bool `json:"isHorseNumVariationGate"`
|
|
TurfVisionType TurfVisionType `json:"turfVisionType"`
|
|
GroundCondition GroundCondition `json:"groundCondition"`
|
|
Weather RaceWeather `json:"weather"`
|
|
Season Season `json:"season"`
|
|
Time RaceTime `json:"time"`
|
|
BaseSpeed float32 `json:"baseSpeed"`
|
|
BorderTimeScaled float32 `json:"borderTimeScaled"`
|
|
ChallengeMatchDifficulty RaceDifficulty `json:"challengeMatchDifficulty"`
|
|
NumRaceHorses int32 `json:"numRaceHorses"`
|
|
PostNumberMax int32 `json:"postNumberMax"`
|
|
PlayerHorseIndex int32 `json:"playerHorseIndex"`
|
|
OverridePlayerHorseIndex int32 `json:"overridePlayerHorseIndex"`
|
|
PlayerTeamMemberArray []HorseData `json:"playerTeamMemberArray"`
|
|
PlayerTeamTopFinishOrderHorse HorseData `json:"playerTeamTopFinishOrderHorse"`
|
|
IsGateInPopularityInitialized bool `json:"isGateInPopularityInitialized"`
|
|
RaceHorse []HorseData `json:"raceHorse"`
|
|
RaceBibMaster struct{} `json:"raceBibMaster"`
|
|
RaceMaster struct{} `json:"raceMaster"`
|
|
RaceInstanceMaster struct{} `json:"raceInstanceMaster"`
|
|
SimDataBase64 string `json:"simDataBase64"`
|
|
SimData struct{} `json:"simData"`
|
|
SimReader struct{} `json:"simReader"`
|
|
EpisodeRaceReplayID int32 `json:"episodeRaceReplayId"`
|
|
IsNotSimulateExport bool `json:"isNotSimulateExport"`
|
|
LaneDistanceMax float32 `json:"laneDistanceMax"`
|
|
ReplayCheckInfo struct{} `json:"replayCheckInfo"`
|
|
ReplayCheckInfoDaily struct{} `json:"replayCheckInfoDaily"`
|
|
ReplayCheckInfoLegend struct{} `json:"replayCheckInfoLegend"`
|
|
IsDailyLegendRace bool `json:"isDailyLegendRace"`
|
|
ReplayCheckInfoChallengeMatch struct{} `json:"replayCheckInfoChallengeMatch"`
|
|
RaceRewardSingle struct{} `json:"raceRewardSingle"`
|
|
ResultHorseIndex int32 `json:"resultHorseIndex"`
|
|
PrevGradeType CharaGradeType `json:"prevGradeType"`
|
|
MainStoryRaceGimmickType MainStoryRaceGimmickType `json:"mainStoryRaceGimmickType"`
|
|
IsMainStoryRaceMatchGimmick bool `json:"isMainStoryRaceMatchGimmick"`
|
|
UnlockFlags uint32 `json:"unlockFlags"`
|
|
PhaseCalculator struct{} `json:"phaseCalculator"`
|
|
HorseIndexByFinishOrder []int32 `json:"horseIndexByFinishOrder"`
|
|
HorseIndexByPopularity []int32 `json:"horseIndexByPopularity"`
|
|
}
|
|
|
|
type RaceType int32
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type RaceType -linecomment -trimprefix RaceType
|
|
const (
|
|
RaceTypeNone RaceType = iota // NONE
|
|
RaceTypePvP
|
|
RaceTypeTutorial
|
|
RaceTypeStory
|
|
RaceTypeStoryCondition
|
|
RaceTypeChampions
|
|
RaceTypeSingle
|
|
RaceTypeSingleModeScenarioTeamRace
|
|
RaceTypeRoomMatch
|
|
RaceTypePractice
|
|
RaceTypeDaily
|
|
RaceTypeTeamBuilding
|
|
RaceTypeLegend
|
|
RaceTypeChallengeMatch
|
|
RaceTypeTeamStadium
|
|
// no value 15
|
|
RaceTypeHeroes RaceType = 16
|
|
|
|
raceTypeMaxInclusive
|
|
)
|
|
|
|
func (r RaceType) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r RaceType) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
var raceTypeNames = sync.OnceValue(func() map[string]RaceType {
|
|
m := make(map[string]RaceType, raceTypeMaxInclusive)
|
|
for r := RaceTypeNone; r <= raceTypeMaxInclusive; r++ {
|
|
s := r.String()
|
|
if strings.HasPrefix(s, "RaceType(") {
|
|
continue
|
|
}
|
|
m[r.String()] = r
|
|
}
|
|
return m
|
|
})
|
|
|
|
func (r *RaceType) UnmarshalText(b []byte) error {
|
|
n, ok := raceTypeNames()[string(b)]
|
|
*r = n
|
|
if !ok {
|
|
return fmt.Errorf("unknown race type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RaceCourseSet struct {
|
|
ID horse.RacecourseID `json:"id"`
|
|
RaceTrackID horse.RaceTrackID `json:"raceTrackId"`
|
|
Distance int32 `json:"distance"`
|
|
Ground int `json:"ground"`
|
|
Inout int `json:"inout"`
|
|
Turn int `json:"turn"`
|
|
FenceSet int `json:"fenceSet"`
|
|
FloatLaneMax int `json:"floatLaneMax"`
|
|
CourseSetStatusID int `json:"courseSetStatusId"`
|
|
FinishTimeMin int `json:"finishTimeMin"`
|
|
FinishTimeMinRandomRange int `json:"finishTimeMinRandomRange"`
|
|
FinishTimeMax int `json:"finishTimeMax"`
|
|
FinishTimeMaxRandomRange int `json:"finishTimeMaxRandomRange"`
|
|
}
|
|
|
|
type InitialLaneType int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type InitialLaneType -trimprefix InitialLane
|
|
const (
|
|
InitialLaneExtraSpaceAfter9 InitialLaneType = iota + 1
|
|
InitialLaneEquidistant
|
|
InitialLaneExtraSpaceAfter14
|
|
InitialLaneExtraSpaceAfter8
|
|
|
|
initialLaneMax
|
|
)
|
|
|
|
func (r InitialLaneType) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r InitialLaneType) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
var initialLaneNames = sync.OnceValue(func() map[string]InitialLaneType {
|
|
m := make(map[string]InitialLaneType, initialLaneMax)
|
|
for r := InitialLaneExtraSpaceAfter9; r < initialLaneMax; r++ {
|
|
s := r.String()
|
|
if strings.HasPrefix(s, "InitialLaneType(") {
|
|
continue
|
|
}
|
|
m[r.String()] = r
|
|
}
|
|
return m
|
|
})
|
|
|
|
func (r *InitialLaneType) UnmarshalText(b []byte) error {
|
|
n, ok := initialLaneNames()[string(b)]
|
|
*r = n
|
|
if !ok {
|
|
return fmt.Errorf("unknown initial lane type type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Rotation int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type Rotation -trimprefix Rotation
|
|
const (
|
|
RotationRight Rotation = iota + 1
|
|
RotationLeft
|
|
RotationStraightRight
|
|
RotationStraightLeft
|
|
)
|
|
|
|
func (r Rotation) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r Rotation) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *Rotation) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Right":
|
|
*r = RotationRight
|
|
case "Left":
|
|
*r = RotationLeft
|
|
case "StraightRight":
|
|
*r = RotationStraightRight
|
|
case "StraightLeft":
|
|
*r = RotationStraightLeft
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown rotation type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ResultBoardConditionType int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type ResultBoardConditionType -linecomment
|
|
const (
|
|
ResultBoardTurfNone ResultBoardConditionType = iota + 1 // Turf_None
|
|
ResultBoardTurfDirt // Turf_Dirt
|
|
ResultBoardDirtNone // Dirt_None
|
|
ResultBoardDirtTurf // Dirt_Turf
|
|
)
|
|
|
|
func (r ResultBoardConditionType) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r ResultBoardConditionType) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *ResultBoardConditionType) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Turf_None":
|
|
*r = ResultBoardTurfNone
|
|
case "Turf_Dirt":
|
|
*r = ResultBoardTurfDirt
|
|
case "Dirt_None":
|
|
*r = ResultBoardDirtNone
|
|
case "Dirt_Turf":
|
|
*r = ResultBoardDirtTurf
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown result board type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CourseDistanceType int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type CourseDistanceType -linecomment -trimprefix Distance
|
|
const (
|
|
DistanceSprint CourseDistanceType = iota + 1 // Short
|
|
DistanceMile
|
|
DistanceMedium // Middle
|
|
DistanceLong
|
|
)
|
|
|
|
func (r CourseDistanceType) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r CourseDistanceType) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *CourseDistanceType) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Short":
|
|
*r = DistanceSprint
|
|
case "Mile":
|
|
*r = DistanceMile
|
|
case "Middle":
|
|
*r = DistanceMedium
|
|
case "Long":
|
|
*r = DistanceLong
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown distance type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type TurfVisionType int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type TurfVisionType -trimprefix TurfVision
|
|
const (
|
|
TurfVisionURA TurfVisionType = iota + 1
|
|
TurfVisionNAU
|
|
TurfVisionStand
|
|
|
|
turfVisionMax
|
|
)
|
|
|
|
func (r TurfVisionType) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r TurfVisionType) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
var turfVisionNames = sync.OnceValue(func() map[string]TurfVisionType {
|
|
m := make(map[string]TurfVisionType, turfVisionMax)
|
|
for r := TurfVisionURA; r < turfVisionMax; r++ {
|
|
s := r.String()
|
|
if strings.HasPrefix(s, "TurfVisionType(") {
|
|
continue
|
|
}
|
|
m[r.String()] = r
|
|
}
|
|
return m
|
|
})
|
|
|
|
func (r *TurfVisionType) UnmarshalText(b []byte) error {
|
|
n, ok := turfVisionNames()[string(b)]
|
|
*r = n
|
|
if !ok {
|
|
return fmt.Errorf("unknown turf vision type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type GroundCondition int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type GroundCondition -linecomment
|
|
const (
|
|
GroundFirm GroundCondition = iota + 1 // Good
|
|
GroundGood // Soft
|
|
GroundSoft // Hard
|
|
GroundHeavy // Bad
|
|
)
|
|
|
|
func (r GroundCondition) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r GroundCondition) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *GroundCondition) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Good":
|
|
*r = GroundFirm
|
|
case "Soft":
|
|
*r = GroundGood
|
|
case "Hard":
|
|
*r = GroundSoft
|
|
case "Bad":
|
|
*r = GroundHeavy
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown ground condition type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RaceWeather int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type RaceWeather -trimprefix Weather
|
|
const (
|
|
WeatherMin RaceWeather = iota
|
|
WeatherSunny
|
|
WeatherCloudy
|
|
WeatherRainy
|
|
WeatherSnow
|
|
WeatherMax
|
|
)
|
|
|
|
func (r RaceWeather) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r RaceWeather) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *RaceWeather) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Min", "NONE":
|
|
*r = WeatherMin
|
|
case "Sunny":
|
|
*r = WeatherSunny
|
|
case "Cloudy":
|
|
*r = WeatherCloudy
|
|
case "Rainy":
|
|
*r = WeatherRainy
|
|
case "Snow":
|
|
*r = WeatherSnow
|
|
case "Max":
|
|
*r = WeatherMax
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown race weather %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Season int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type Season -trimprefix Season
|
|
const (
|
|
SeasonMin Season = iota
|
|
SeasonSpring
|
|
SeasonSummer
|
|
SeasonFall
|
|
SeasonWinter
|
|
SeasonCherryBlossom
|
|
SeasonMax
|
|
)
|
|
|
|
func (r Season) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r Season) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *Season) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Min", "NONE":
|
|
*r = SeasonMin
|
|
case "Spring":
|
|
*r = SeasonSpring
|
|
case "Summer":
|
|
*r = SeasonSummer
|
|
case "Fall":
|
|
*r = SeasonFall
|
|
case "Winter":
|
|
*r = SeasonWinter
|
|
case "CherryBlossom":
|
|
*r = SeasonCherryBlossom
|
|
case "Max":
|
|
*r = SeasonMax
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown season %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RaceTime int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type RaceTime -trimprefix Time
|
|
const (
|
|
TimeMin RaceTime = iota
|
|
TimeMorning
|
|
TimeDaytime
|
|
TimeEvening
|
|
TimeNight
|
|
TimeMax
|
|
)
|
|
|
|
func (r RaceTime) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r RaceTime) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *RaceTime) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Min":
|
|
*r = TimeMin
|
|
case "Morning":
|
|
*r = TimeMorning
|
|
case "Daytime":
|
|
*r = TimeDaytime
|
|
case "Evening":
|
|
*r = TimeEvening
|
|
case "Night":
|
|
*r = TimeNight
|
|
case "Max":
|
|
*r = TimeMax
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown race time %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RaceDifficulty int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type RaceDifficulty -trimprefix Difficulty
|
|
const (
|
|
DifficultyEasy RaceDifficulty = iota + 1
|
|
DifficultyNormal
|
|
DifficultyHard
|
|
DifficultyVeryHard
|
|
DifficultyExtreme
|
|
|
|
difficultyMax
|
|
)
|
|
|
|
func (r RaceDifficulty) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r RaceDifficulty) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
var difficultyNames = sync.OnceValue(func() map[string]RaceDifficulty {
|
|
m := make(map[string]RaceDifficulty, difficultyMax)
|
|
for r := DifficultyEasy; r < difficultyMax; r++ {
|
|
s := r.String()
|
|
if strings.HasPrefix(s, "RaceDifficulty(") {
|
|
continue
|
|
}
|
|
m[r.String()] = r
|
|
}
|
|
// extra one for pure pvp races
|
|
m["UNKNOWN"] = 0
|
|
return m
|
|
})
|
|
|
|
func (r *RaceDifficulty) UnmarshalText(b []byte) error {
|
|
n, ok := difficultyNames()[string(b)]
|
|
*r = n
|
|
if !ok {
|
|
return fmt.Errorf("unknown turf vision type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type RaceParam struct {
|
|
RawSpeed int `json:"rawSpeed"`
|
|
RawStamina int `json:"rawStamina"`
|
|
RawPow int `json:"rawPow"`
|
|
RawGuts int `json:"rawGuts"`
|
|
RawWiz int `json:"rawWiz"`
|
|
BaseSpeed float32 `json:"baseSpeed"`
|
|
BaseStamina float32 `json:"baseStamina"`
|
|
BasePow float32 `json:"basePow"`
|
|
BaseGuts float32 `json:"baseGuts"`
|
|
BaseWiz float32 `json:"baseWiz"`
|
|
Motivation Motivation `json:"motivation"`
|
|
MotivationCoef float32 `json:"motivationCoef"`
|
|
}
|
|
|
|
type Motivation int32
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type Motivation -linecomment
|
|
const (
|
|
MotivationNone Motivation = iota // None
|
|
MotivationAwful // Min
|
|
MotivationBad // Low
|
|
MotivationNormal // Middle
|
|
MotivationGood // High
|
|
MotivationGreat // Max
|
|
)
|
|
|
|
func (r Motivation) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r Motivation) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *Motivation) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Min":
|
|
*r = MotivationAwful
|
|
case "Low":
|
|
*r = MotivationBad
|
|
case "Middle":
|
|
*r = MotivationNormal
|
|
case "High":
|
|
*r = MotivationGood
|
|
case "Max":
|
|
*r = MotivationGreat
|
|
case "None":
|
|
*r = MotivationNone
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown motivation %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type SkillArray struct {
|
|
SkillID horse.SkillID `json:"skill_id"`
|
|
Level int32 `json:"level"`
|
|
}
|
|
|
|
type RaceResult struct {
|
|
Turn int32 `json:"turn"`
|
|
ProgramID int32 `json:"program_id"`
|
|
Weather int32 `json:"weather"`
|
|
GroundCondition int32 `json:"ground_condition"`
|
|
RunningStyle int32 `json:"running_style"`
|
|
Popularity int32 `json:"popularity"`
|
|
ResultRank int32 `json:"result_rank"`
|
|
ResultTime int32 `json:"result_time"`
|
|
PrizeMoney int32 `json:"prize_money"`
|
|
}
|
|
|
|
type RaceHorseData struct {
|
|
FrameOrder int32 `json:"frame_order"`
|
|
ViewerID int64 `json:"viewer_id"`
|
|
TrainerName *string `json:"trainer_name"`
|
|
OwnerViewerID int64 `json:"owner_viewer_id"`
|
|
OwnerTrainerName string `json:"owner_trainer_name"`
|
|
SingleModeCharaID int32 `json:"single_mode_chara_id"`
|
|
TrainedCharaID int32 `json:"trained_chara_id"`
|
|
NicknameID int32 `json:"nickname_id"`
|
|
CharaID int32 `json:"chara_id"`
|
|
CardID int32 `json:"card_id"`
|
|
MobID int32 `json:"mob_id"`
|
|
Rarity int32 `json:"rarity"`
|
|
TalentLevel int32 `json:"talent_level"`
|
|
SkillArray []SkillArray `json:"skill_array"`
|
|
Stamina int32 `json:"stamina"`
|
|
Speed int32 `json:"speed"`
|
|
Pow int32 `json:"pow"`
|
|
Guts int32 `json:"guts"`
|
|
Wiz int32 `json:"wiz"`
|
|
RunningStyle int32 `json:"running_style"`
|
|
RaceDressID int32 `json:"race_dress_id"`
|
|
CharaColorType int32 `json:"chara_color_type"`
|
|
NpcType int32 `json:"npc_type"`
|
|
FinalGrade int32 `json:"final_grade"`
|
|
Popularity int32 `json:"popularity"`
|
|
PopularityMarkRankArray []int32 `json:"popularity_mark_rank_array"`
|
|
ProperDistanceShort int32 `json:"proper_distance_short"`
|
|
ProperDistanceMile int32 `json:"proper_distance_mile"`
|
|
ProperDistanceMiddle int32 `json:"proper_distance_middle"`
|
|
ProperDistanceLong int32 `json:"proper_distance_long"`
|
|
ProperRunningStyleNige int32 `json:"proper_running_style_nige"`
|
|
ProperRunningStyleSenko int32 `json:"proper_running_style_senko"`
|
|
ProperRunningStyleSashi int32 `json:"proper_running_style_sashi"`
|
|
ProperRunningStyleOikomi int32 `json:"proper_running_style_oikomi"`
|
|
ProperGroundTurf int32 `json:"proper_ground_turf"`
|
|
ProperGroundDirt int32 `json:"proper_ground_dirt"`
|
|
Motivation int32 `json:"motivation"`
|
|
WinSaddleIDArray []int32 `json:"win_saddle_id_array"`
|
|
RaceResultArray []RaceResult `json:"race_result_array"`
|
|
TeamID int32 `json:"team_id"`
|
|
TeamMemberID int32 `json:"team_member_id"`
|
|
TeamRank int32 `json:"team_rank"`
|
|
SingleModeWinCount int32 `json:"single_mode_win_count"`
|
|
FanCount int32 `json:"fan_count"`
|
|
ItemIDArray []int32 `json:"item_id_array"`
|
|
MotivationChangeFlag int32 `json:"motivation_change_flag"`
|
|
FrameOrderChangeFlag int32 `json:"frame_order_change_flag"`
|
|
}
|
|
|
|
type HorseData struct {
|
|
HorseIndex int32 `json:"horseIndex"`
|
|
PostNumber int32 `json:"postNumber"`
|
|
CharaID horse.CharacterID `json:"charaId"`
|
|
CharaName string `json:"charaName"`
|
|
FinishOrder int32 `json:"finishOrder"`
|
|
FinishTimeRaw float32 `json:"finishTimeRaw"`
|
|
FinishTimeScaled float32 `json:"finishTimeScaled"`
|
|
FinishDiffTimeFromPrev float32 `json:"finishDiffTimeFromPrev"`
|
|
RaceParam RaceParam `json:"raceParam"`
|
|
ResponseHorseData RaceHorseData `json:"responseHorseData"`
|
|
Popularity int32 `json:"popularity"`
|
|
PopularityRankLeft int8 `json:"popularityRankLeft"`
|
|
PopularityRankCenter int8 `json:"popularityRankCenter"`
|
|
PopularityRankRight int8 `json:"popularityRankRight"`
|
|
GateInPopularity int8 `json:"gateInPopularity"`
|
|
Rarity CardRarity `json:"rarity"`
|
|
TrainerName string `json:"trainerName"`
|
|
IsGhost bool `json:"isGhost"`
|
|
IsRunningStyleExInitialized bool `json:"isRunningStyleExInitialized"`
|
|
RunningStyleEx RunningStyleEx `json:"runningStyleEx"`
|
|
Defeat string `json:"defeat"` // this is an enum, but not worth the effort
|
|
RaceDressID int32 `json:"raceDressId"`
|
|
RaceDressIDWithOption int32 `json:"raceDressIdWithOption"`
|
|
RunningType string `json:"runningType"` // enum not worth
|
|
ActiveProperDistance ProperGrade `json:"activeProperDistance"`
|
|
ActiveProperGroundType ProperGrade `json:"activeProperGroundType"`
|
|
MobID int32 `json:"mobId"`
|
|
RaceRecord struct{} `json:"raceRecord"`
|
|
FinishOrderRawScore int32 `json:"finishOrderRawScore"`
|
|
TrainedCharaData TrainedCharaData `json:"trainedCharaData"`
|
|
}
|
|
|
|
type RunningStyleEx int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type RunningStyleEx -linecomment
|
|
const (
|
|
StyleExNone RunningStyleEx = iota // NONE
|
|
StyleExRunaway // Oonige
|
|
)
|
|
|
|
func (r RunningStyleEx) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r RunningStyleEx) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *RunningStyleEx) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "NONE":
|
|
*r = StyleExNone
|
|
case "Oonige":
|
|
*r = StyleExRunaway
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown extra running style %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ProperGrade int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type ProperGrade -trimprefix Aptitude
|
|
const (
|
|
AptitudeNull ProperGrade = iota
|
|
AptitudeG
|
|
AptitudeF
|
|
AptitudeE
|
|
AptitudeD
|
|
AptitudeC
|
|
AptitudeB
|
|
AptitudeA
|
|
AptitudeS
|
|
)
|
|
|
|
func (r ProperGrade) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r ProperGrade) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *ProperGrade) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "Null":
|
|
*r = AptitudeNull
|
|
case "G":
|
|
*r = AptitudeG
|
|
case "F":
|
|
*r = AptitudeF
|
|
case "E":
|
|
*r = AptitudeE
|
|
case "D":
|
|
*r = AptitudeD
|
|
case "C":
|
|
*r = AptitudeC
|
|
case "B":
|
|
*r = AptitudeB
|
|
case "A":
|
|
*r = AptitudeA
|
|
case "S":
|
|
*r = AptitudeS
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown motivation %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type TrainedCharaData struct {
|
|
ID int32 `json:"id"`
|
|
IsSaved bool `json:"isSaved"`
|
|
ViewerID int64 `json:"viewerId"`
|
|
OwnerViewerID int64 `json:"ownerViewerId"`
|
|
OwnerTrainedCharaID int32 `json:"ownerTrainedCharaId"`
|
|
UseType int32 `json:"useType"`
|
|
CardID horse.UmaID `json:"cardId"`
|
|
NickNameID int32 `json:"nickNameId"`
|
|
NickNameIDArray []int32 `json:"nickNameIdArray"`
|
|
Stamina int32 `json:"stamina"`
|
|
Speed int32 `json:"speed"`
|
|
Power int32 `json:"power"`
|
|
Guts int32 `json:"guts"`
|
|
Wiz int32 `json:"wiz"`
|
|
Fans int32 `json:"fans"`
|
|
Rank int32 `json:"rank"`
|
|
RankScore int32 `json:"rankScore"`
|
|
RunningStyle int32 `json:"runningStyle"`
|
|
ProperGroundTurf int32 `json:"properGroundTurf"`
|
|
ProperGroundDirt int32 `json:"properGroundDirt"`
|
|
ProperDistanceShort int32 `json:"properDistanceShort"`
|
|
ProperDistanceMile int32 `json:"properDistanceMile"`
|
|
ProperDistanceMiddle int32 `json:"properDistanceMiddle"`
|
|
ProperDistanceLong int32 `json:"properDistanceLong"`
|
|
ProperRunningStyleNige int32 `json:"properRunningStyleNige"`
|
|
ProperRunningStyleSenko int32 `json:"properRunningStyleSenko"`
|
|
ProperRunningStyleSashi int32 `json:"properRunningStyleSashi"`
|
|
ProperRunningStyleOikomi int32 `json:"properRunningStyleOikomi"`
|
|
SuccessionCount int32 `json:"successionCount"`
|
|
FactorDataArray []FactorData `json:"factorDataArray"`
|
|
CreateTime string `json:"createTime"`
|
|
ScenarioID horse.ScenarioID `json:"scenarioId"`
|
|
TalentLevel int32 `json:"talentLevel"`
|
|
CharaGrade int32 `json:"charaGrade"`
|
|
Rarity int32 `json:"rarity"`
|
|
IsLock bool `json:"isLock"`
|
|
FavoriteData struct{} `json:"favoriteData"`
|
|
CachedCreateTimeTimeStamp int64 `json:"cachedCreateTimeTimeStamp"`
|
|
SortedFactorList []umadump.Never `json:"sortedFactorList"`
|
|
SortedFactorProfileCardList []umadump.Never `json:"sortedFactorProfileCardList"`
|
|
FactorListIncludingSuccession []umadump.Never `json:"factorListIncludingSuccession"`
|
|
SuccessionCharaList []SuccessionCharaList `json:"successionCharaList"`
|
|
IsSuccessionHistoryInitialized bool `json:"isSuccessionHistoryInitialized"`
|
|
SuccessionHistoryList []umadump.Never `json:"successionHistoryList"`
|
|
AcquiredSkillArray []AcquiredSkill `json:"acquiredSkillArray"`
|
|
SupportCardArray []SupportCard `json:"supportCardArray"`
|
|
SingleModeRaceResultArray []SingleModeRaceResult `json:"singleModeRaceResultArray"`
|
|
WinSaddleArray []umadump.Never `json:"winSaddleArray"`
|
|
WinSaddleIDArray []horse.SaddleID `json:"winSaddleIdArray"`
|
|
CacheCharaID int32 `json:"cacheCharaId"`
|
|
MasterCardData struct{} `json:"masterCardData"`
|
|
MasterCharaData struct{} `json:"masterCharaData"`
|
|
MasterCardRarityData struct{} `json:"masterCardRarityData"`
|
|
SingleTotalRaceNum int32 `json:"singleTotalRaceNum"`
|
|
SingleWinNum int32 `json:"singleWinNum"`
|
|
TrainedCharaDataAccessor struct{} `json:"trainedCharaDataAccessor"`
|
|
}
|
|
|
|
type FactorData struct {
|
|
FactorLv int32 `json:"factorLv"`
|
|
FactorID horse.SparkID `json:"factorId"`
|
|
BaseFactorID horse.SparkID `json:"baseFactorId"`
|
|
UpgradeHistoryList []umadump.Never `json:"upgradeHistoryList"`
|
|
}
|
|
|
|
type SuccessionCharaList struct {
|
|
PositionID int32 `json:"positionId"`
|
|
CardID int32 `json:"cardId"`
|
|
Rarity int32 `json:"rarity"`
|
|
Level int32 `json:"level"`
|
|
Rank int32 `json:"rank"`
|
|
FactorDataArray []FactorData `json:"factorDataArray"`
|
|
SortedFactorList []umadump.Never `json:"sortedFactorList"`
|
|
SortedFactorListForProfileCard []umadump.Never `json:"sortedFactorListForProfileCard"`
|
|
OwnerViewerID int64 `json:"ownerViewerId"`
|
|
IsPlayer bool `json:"isPlayer"`
|
|
WinSaddleArray []umadump.Never `json:"winSaddleArray"`
|
|
WinSaddleIDArray []int32 `json:"winSaddleIdArray"`
|
|
}
|
|
|
|
type AcquiredSkill struct {
|
|
MasterID horse.SkillID `json:"masterId"`
|
|
Level int `json:"level"`
|
|
Master struct{} `json:"master"`
|
|
}
|
|
|
|
type SupportCard struct {
|
|
Position int32 `json:"position"`
|
|
SupportCardID horse.SupportCardID `json:"supportCardId"`
|
|
LimitBreakCount int32 `json:"limitBreakCount"`
|
|
Exp int32 `json:"exp"`
|
|
}
|
|
|
|
type SingleModeRaceResult struct {
|
|
Turn int `json:"turn"`
|
|
ProgramID int `json:"programId"`
|
|
RaceInstanceID int `json:"raceInstanceId"`
|
|
FrameOrder int `json:"frameOrder"`
|
|
NpcCount int `json:"npcCount"`
|
|
Weather int `json:"weather"`
|
|
GroundCondition int `json:"groundCondition"`
|
|
RunningStyle int `json:"runningStyle"`
|
|
ResultRank int `json:"resultRank"`
|
|
ScenarioID int `json:"scenarioId"`
|
|
}
|
|
|
|
type CardRarity int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type CardRarity -linecomment -trimprefix Card
|
|
const (
|
|
CardNone CardRarity = iota // NONE
|
|
CardRare1
|
|
CardRare2
|
|
CardRare3
|
|
CardRare4
|
|
CardRare5
|
|
)
|
|
|
|
func (r CardRarity) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r CardRarity) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
func (r *CardRarity) UnmarshalText(b []byte) error {
|
|
switch string(b) {
|
|
case "NONE":
|
|
*r = CardNone
|
|
case "Rare1":
|
|
*r = CardRare1
|
|
case "Rare2":
|
|
*r = CardRare2
|
|
case "Rare3":
|
|
*r = CardRare3
|
|
case "Rare4":
|
|
*r = CardRare4
|
|
case "Rare5":
|
|
*r = CardRare5
|
|
default:
|
|
*r = 0
|
|
return fmt.Errorf("unknown card rarity %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type CharaGradeType int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type CharaGradeType -linecomment -trimprefix CharaGrade
|
|
const (
|
|
CharaGradeNone CharaGradeType = iota // NONE
|
|
CharaGradeDebut
|
|
CharaGradeNoWin
|
|
CharaGradeOpen
|
|
CharaGradeG3Silver
|
|
CharaGradeG3Gold
|
|
CharaGradeG2Silver
|
|
CharaGradeG2Gold
|
|
CharaGradeG1Bronze
|
|
CharaGradeG1Silver
|
|
CharaGradeG1Gold
|
|
|
|
charaGradeMax
|
|
)
|
|
|
|
func (r CharaGradeType) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r CharaGradeType) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
var charaGradeNames = sync.OnceValue(func() map[string]CharaGradeType {
|
|
m := make(map[string]CharaGradeType, raceTypeMaxInclusive)
|
|
for r := CharaGradeNone; r < charaGradeMax; r++ {
|
|
s := r.String()
|
|
if strings.HasPrefix(s, "CharaGradeType(") {
|
|
continue
|
|
}
|
|
m[r.String()] = r
|
|
}
|
|
return m
|
|
})
|
|
|
|
func (r *CharaGradeType) UnmarshalText(b []byte) error {
|
|
n, ok := charaGradeNames()[string(b)]
|
|
*r = n
|
|
if !ok {
|
|
return fmt.Errorf("unknown chara grade type %q", b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type MainStoryRaceGimmickType int8
|
|
|
|
//go:generate go run golang.org/x/tools/cmd/stringer@v0.41.0 -type MainStoryRaceGimmickType -linecomment
|
|
const (
|
|
GimmickNone MainStoryRaceGimmickType = iota // NONE
|
|
GimmickSpecial00 // Special_00
|
|
|
|
gimmickMax
|
|
)
|
|
|
|
func (r MainStoryRaceGimmickType) AppendText(b []byte) ([]byte, error) {
|
|
return append(b, r.String()...), nil
|
|
}
|
|
|
|
func (r MainStoryRaceGimmickType) MarshalText() ([]byte, error) {
|
|
return r.AppendText(nil)
|
|
}
|
|
|
|
var mainStoryGimmickNames = sync.OnceValue(func() map[string]MainStoryRaceGimmickType {
|
|
m := make(map[string]MainStoryRaceGimmickType, raceTypeMaxInclusive)
|
|
for r := GimmickNone; r < gimmickMax; r++ {
|
|
s := r.String()
|
|
if strings.HasPrefix(s, "MainStoryRaceGimmickType(") {
|
|
continue
|
|
}
|
|
m[r.String()] = r
|
|
}
|
|
return m
|
|
})
|
|
|
|
func (r *MainStoryRaceGimmickType) UnmarshalText(b []byte) error {
|
|
n, ok := mainStoryGimmickNames()[string(b)]
|
|
*r = n
|
|
if !ok {
|
|
return fmt.Errorf("unknown main story race gimmick type %q", b)
|
|
}
|
|
return nil
|
|
}
|