527 lines
15 KiB
Go
527 lines
15 KiB
Go
package domain
|
|
|
|
import (
|
|
"fmt"
|
|
"math"
|
|
"sort"
|
|
)
|
|
|
|
// rankEpsilon 用于判定「成绩相同」。计时/测距保留两位小数，1e-9 足够区分。
|
|
const rankEpsilon = 1e-9
|
|
|
|
// ScoreOptions 控制引擎的可选行为；零值即本次运动会的口径。
|
|
type ScoreOptions struct {
|
|
// UnionAttribution 决定联队成绩的归属；空值等同 UnionWhole（整体记给主单位）。
|
|
// 未实现：生产链路没有赋值入口，联队份额也无处加载（见 UnionAttribution 注释）。
|
|
UnionAttribution UnionAttribution
|
|
// IncludeDrafts 为 true 时草稿成绩也参与计分；默认只算已发布（草稿不上屏也不计分）。
|
|
IncludeDrafts bool
|
|
}
|
|
|
|
// EventScoreInput 是一次小项（某组别）计分的全部输入，引擎只读不改。
|
|
type EventScoreInput struct {
|
|
Event Event
|
|
Category EventCategory
|
|
Channels []ScoreChannel
|
|
Profiles map[int64]ScoringProfile
|
|
Entries []Entry
|
|
Results []Result
|
|
RecordBonus *RecordBonusConfig
|
|
RecordBreaks []RecordBreak
|
|
Options ScoreOptions
|
|
}
|
|
|
|
// EventScore 是一次小项计分的结果。
|
|
type EventScore struct {
|
|
Ledger []LedgerEntry
|
|
Ranked []RankedResult
|
|
}
|
|
|
|
// RankedResult 记录「某条报名项在某通道下拿到的名次与原始积分」。
|
|
// Points 尚未按联队份额拆分、也未乘个人→单位系数，因此可直接用于奖牌判定与分项成绩表。
|
|
type RankedResult struct {
|
|
EntryID int64
|
|
ResultID int64
|
|
EventID int64
|
|
CategoryID int64
|
|
ChannelID int64
|
|
Scope Scope
|
|
Basis Basis
|
|
AthleteID int64
|
|
AthleteName string
|
|
TeamID int64
|
|
Shares []TeamShare
|
|
Rank int
|
|
Points float64
|
|
ResultValue *float64
|
|
Status ResultStatus
|
|
}
|
|
|
|
// ScoreEvent 按项目的计分通道逐条计算名次与积分，输出流水与名次明细。
|
|
// 计分与排名解耦：项目 scored=false 或没有通道时照样产出名次（Points=0），只是不写流水。
|
|
// 没有通道时按小项自身的录入方式（result_mode）推导排名口径，见 rankOnlyChannel。
|
|
func ScoreEvent(in EventScoreInput) (EventScore, error) {
|
|
var out EventScore
|
|
rankOnly := len(in.Channels) == 0
|
|
channels := sortedChannels(in.Channels)
|
|
if rankOnly {
|
|
channels = []ScoreChannel{rankOnlyChannel(in)}
|
|
}
|
|
|
|
for _, ch := range channels {
|
|
// 不计分时不需要积分表：既不查模板，也不可能算出非零分。
|
|
profile := ScoringProfile{}
|
|
if in.Event.Scored && !rankOnly {
|
|
p, ok := in.Profiles[ch.ProfileID]
|
|
if !ok {
|
|
return EventScore{}, fmt.Errorf("%w: 通道 %d 引用模板 %d", ErrProfileNotFound, ch.ID, ch.ProfileID)
|
|
}
|
|
profile = p
|
|
}
|
|
ranked, err := scoreChannel(in, ch, profile)
|
|
if err != nil {
|
|
return EventScore{}, err
|
|
}
|
|
if !in.Event.Scored {
|
|
for i := range ranked {
|
|
ranked[i].Points = 0
|
|
}
|
|
}
|
|
out.Ranked = append(out.Ranked, ranked...)
|
|
if in.Event.Scored {
|
|
out.Ledger = append(out.Ledger, ledgerFromRanked(in, ch, ranked)...)
|
|
}
|
|
}
|
|
|
|
if !in.Event.Scored {
|
|
return out, nil
|
|
}
|
|
bonus, err := recordBonusLedger(in)
|
|
if err != nil {
|
|
return EventScore{}, err
|
|
}
|
|
out.Ledger = append(out.Ledger, bonus...)
|
|
return out, nil
|
|
}
|
|
|
|
// rankOnlyChannel 在没有计分通道时，按小项自身的录入方式推导排名口径：
|
|
// manual 直接录名次，其余按成绩自动排名；名次记给个人，团体/对抗项目记给单位。
|
|
func rankOnlyChannel(in EventScoreInput) ScoreChannel {
|
|
basis := BasisResult
|
|
if in.Event.ResultMode == ResultModeManual {
|
|
basis = BasisManual
|
|
}
|
|
scope := ScopeAthlete
|
|
if in.Event.EventType == EventTypeTeam || in.Event.EventType == EventTypeMatch {
|
|
scope = ScopeTeam
|
|
}
|
|
return ScoreChannel{EventID: in.Event.ID, Scope: scope, Basis: basis}
|
|
}
|
|
|
|
// sortedChannels 固定通道处理顺序，保证同一份输入每次产出同样的流水顺序。
|
|
func sortedChannels(channels []ScoreChannel) []ScoreChannel {
|
|
out := append([]ScoreChannel(nil), channels...)
|
|
sort.SliceStable(out, func(i, j int) bool {
|
|
if out[i].SortOrder != out[j].SortOrder {
|
|
return out[i].SortOrder < out[j].SortOrder
|
|
}
|
|
return out[i].ID < out[j].ID
|
|
})
|
|
return out
|
|
}
|
|
|
|
func scoreChannel(in EventScoreInput, ch ScoreChannel, profile ScoringProfile) ([]RankedResult, error) {
|
|
switch ch.Basis {
|
|
case BasisResult:
|
|
return scoreByResult(in, ch, profile)
|
|
case BasisManual:
|
|
return scoreByManual(in, ch, profile)
|
|
case BasisAggregate:
|
|
return scoreByAggregate(in, ch, profile)
|
|
default:
|
|
return nil, fmt.Errorf("%w: %q", ErrUnknownBasis, ch.Basis)
|
|
}
|
|
}
|
|
|
|
// candidate 是排名过程的中间态：一条可参与排名的报名项 + 它的比较值。
|
|
type candidate struct {
|
|
entry Entry
|
|
result Result
|
|
subject int64 // 聚合通道的排名主体（单位或运动员）
|
|
value float64 // 排序用比较值
|
|
rankIn int // manual 通道录入的名次
|
|
}
|
|
|
|
// collectCandidates 过滤出本通道真正参与排名的报名项：
|
|
// 只取已发布、状态正常、且带有本通道所需数据的成绩。
|
|
func collectCandidates(in EventScoreInput, ch ScoreChannel) ([]candidate, error) {
|
|
if ch.Basis == BasisResult && in.Event.Compare == CompareNone {
|
|
return nil, ErrCompareRequired
|
|
}
|
|
if ch.Basis == BasisAggregate && in.Event.Compare == CompareNone {
|
|
return nil, ErrCompareRequired
|
|
}
|
|
|
|
byEntry := make(map[int64]Result, len(in.Results))
|
|
for _, r := range in.Results {
|
|
byEntry[r.EntryID] = r
|
|
}
|
|
|
|
out := make([]candidate, 0, len(in.Entries))
|
|
for _, e := range in.Entries {
|
|
if in.Event.ID != 0 && e.EventID != 0 && e.EventID != in.Event.ID {
|
|
continue
|
|
}
|
|
if in.Category.ID != 0 && e.CategoryID != in.Category.ID {
|
|
continue
|
|
}
|
|
if !e.Status.rankable() {
|
|
continue
|
|
}
|
|
r, ok := byEntry[e.ID]
|
|
if !ok {
|
|
continue
|
|
}
|
|
if r.State == ResultStateDraft && !in.Options.IncludeDrafts {
|
|
continue
|
|
}
|
|
if !r.Status.rankable() {
|
|
continue
|
|
}
|
|
|
|
c := candidate{entry: e, result: r}
|
|
switch ch.Basis {
|
|
case BasisManual:
|
|
if r.Rank <= 0 {
|
|
continue
|
|
}
|
|
c.rankIn = r.Rank
|
|
default: // result / aggregate 都按成绩值排序
|
|
if r.ResultValue == nil {
|
|
continue
|
|
}
|
|
c.value = *r.ResultValue
|
|
}
|
|
out = append(out, c)
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func scoreByResult(in EventScoreInput, ch ScoreChannel, profile ScoringProfile) ([]RankedResult, error) {
|
|
cands, err := collectCandidates(in, ch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sortCandidatesByValue(cands, in.Event.Compare)
|
|
return rankGroups(in, ch, profile, groupByValue(cands)), nil
|
|
}
|
|
|
|
func scoreByManual(in EventScoreInput, ch ScoreChannel, profile ScoringProfile) ([]RankedResult, error) {
|
|
cands, err := collectCandidates(in, ch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sort.SliceStable(cands, func(i, j int) bool {
|
|
if cands[i].rankIn != cands[j].rankIn {
|
|
return cands[i].rankIn < cands[j].rankIn
|
|
}
|
|
return cands[i].entry.ID < cands[j].entry.ID
|
|
})
|
|
return rankGroups(in, ch, profile, groupByManualRank(cands)), nil
|
|
}
|
|
|
|
// tieGroup 是一组并列的参赛者；startRank 是它们共同展示的名次。
|
|
type tieGroup struct {
|
|
startRank int
|
|
members []candidate
|
|
}
|
|
|
|
// groupByValue 按成绩值分组：值相同即并列，名次按「占位顺推」计算（skip 口径）。
|
|
func groupByValue(cands []candidate) []tieGroup {
|
|
var groups []tieGroup
|
|
pos := 1
|
|
for i := 0; i < len(cands); {
|
|
j := i + 1
|
|
for j < len(cands) && nearlyEqual(cands[j].value, cands[i].value) {
|
|
j++
|
|
}
|
|
groups = append(groups, tieGroup{startRank: pos, members: cands[i:j]})
|
|
pos += j - i
|
|
i = j
|
|
}
|
|
return groups
|
|
}
|
|
|
|
// groupByManualRank 按录入名次分组：录入名次就是展示名次，不做顺推改写。
|
|
func groupByManualRank(cands []candidate) []tieGroup {
|
|
var groups []tieGroup
|
|
for i := 0; i < len(cands); {
|
|
j := i + 1
|
|
for j < len(cands) && cands[j].rankIn == cands[i].rankIn {
|
|
j++
|
|
}
|
|
groups = append(groups, tieGroup{startRank: cands[i].rankIn, members: cands[i:j]})
|
|
i = j
|
|
}
|
|
return groups
|
|
}
|
|
|
|
// rankGroups 给每组分配积分并产出名次明细。
|
|
func rankGroups(in EventScoreInput, ch ScoreChannel, profile ScoringProfile, groups []tieGroup) []RankedResult {
|
|
lastRank := 0
|
|
for _, g := range groups {
|
|
if r := g.startRank + len(g.members) - 1; r > lastRank {
|
|
lastRank = r
|
|
}
|
|
}
|
|
|
|
var out []RankedResult
|
|
for _, g := range groups {
|
|
pts := groupPoints(profile, g.startRank, len(g.members), lastRank, in.Event, in.Category)
|
|
for _, c := range g.members {
|
|
out = append(out, rankedResult(in, ch, c, g.startRank, pts))
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// groupPoints 计算一组并列者拿到的分。
|
|
// 三种口径都先确定这组「占用了哪些名次」：startRank .. startRank+size-1。
|
|
func groupPoints(profile ScoringProfile, startRank, size, lastRank int, ev Event, cat EventCategory) float64 {
|
|
if startRank <= 0 || size <= 0 {
|
|
return 0
|
|
}
|
|
// lastPlaceZero 是对「最后一名」的覆盖；并列在末位的整组都按最后一名处理，
|
|
// 否则同组出现 0 与 1 两种分数，违背「并列同分」的语义。
|
|
if profile.LastPlaceZero && startRank <= lastRank && lastRank <= startRank+size-1 {
|
|
return 0
|
|
}
|
|
|
|
switch profile.tieMode() {
|
|
case TieAverage:
|
|
var sum float64
|
|
for r := startRank; r < startRank+size; r++ {
|
|
p, _ := basePoints(profile, r, ev, cat)
|
|
sum += p
|
|
}
|
|
return sum / float64(size)
|
|
case TieHigher:
|
|
best := 0.0
|
|
for r := startRank; r < startRank+size; r++ {
|
|
if p, ok := basePoints(profile, r, ev, cat); ok && p > best {
|
|
best = p
|
|
}
|
|
}
|
|
return best
|
|
default: // TieSkip
|
|
p, _ := basePoints(profile, startRank, ev, cat)
|
|
return p
|
|
}
|
|
}
|
|
|
|
// basePoints 查表得分并乘项目权重、组别权重；超出录取名次或表中无名次一律 0。
|
|
func basePoints(profile ScoringProfile, rank int, ev Event, cat EventCategory) (float64, bool) {
|
|
if rank <= 0 {
|
|
return 0, false
|
|
}
|
|
if profile.AwardRanks > 0 && rank > profile.AwardRanks {
|
|
return 0, false
|
|
}
|
|
p, ok := profile.pointsAt(rank)
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
return p * ev.multiplier() * cat.multiplier(), true
|
|
}
|
|
|
|
func rankedResult(in EventScoreInput, ch ScoreChannel, c candidate, rank int, points float64) RankedResult {
|
|
rr := RankedResult{
|
|
EntryID: c.entry.ID,
|
|
ResultID: c.result.ID,
|
|
EventID: in.Event.ID,
|
|
CategoryID: in.Category.ID,
|
|
ChannelID: ch.ID,
|
|
Scope: ch.Scope,
|
|
Basis: ch.Basis,
|
|
AthleteID: c.entry.AthleteID,
|
|
AthleteName: c.entry.AthleteName,
|
|
TeamID: c.entry.primaryTeamID(),
|
|
Shares: c.entry.resolvedShares(in.Options.UnionAttribution),
|
|
Rank: rank,
|
|
Points: points,
|
|
Status: c.result.Status,
|
|
}
|
|
if c.result.ResultValue != nil {
|
|
v := *c.result.ResultValue
|
|
rr.ResultValue = &v
|
|
}
|
|
return rr
|
|
}
|
|
|
|
// scoreByAggregate 先把同一主体的成绩汇总成一个值（求和），再按值排名（预留能力）。
|
|
func scoreByAggregate(in EventScoreInput, ch ScoreChannel, profile ScoringProfile) ([]RankedResult, error) {
|
|
cands, err := collectCandidates(in, ch)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
type bucket struct {
|
|
subject int64
|
|
entry Entry
|
|
total float64
|
|
}
|
|
order := make([]int64, 0)
|
|
buckets := make(map[int64]*bucket)
|
|
for _, c := range cands {
|
|
subject := c.entry.TeamID
|
|
if ch.Scope == ScopeAthlete {
|
|
subject = c.entry.AthleteID
|
|
}
|
|
if subject == 0 {
|
|
continue
|
|
}
|
|
b, ok := buckets[subject]
|
|
if !ok {
|
|
b = &bucket{subject: subject, entry: c.entry}
|
|
buckets[subject] = b
|
|
order = append(order, subject)
|
|
}
|
|
b.total += c.value
|
|
}
|
|
|
|
agg := make([]candidate, 0, len(order))
|
|
for _, id := range order {
|
|
b := buckets[id]
|
|
c := candidate{entry: b.entry, subject: b.subject, value: b.total}
|
|
c.entry.ID = 0 // 聚合结果不对应单条报名项
|
|
agg = append(agg, c)
|
|
}
|
|
sortCandidatesByValue(agg, in.Event.Compare)
|
|
|
|
groups := groupByValue(agg)
|
|
lastRank := 0
|
|
for _, g := range groups {
|
|
if r := g.startRank + len(g.members) - 1; r > lastRank {
|
|
lastRank = r
|
|
}
|
|
}
|
|
|
|
var out []RankedResult
|
|
for _, g := range groups {
|
|
pts := groupPoints(profile, g.startRank, len(g.members), lastRank, in.Event, in.Category)
|
|
for _, c := range g.members {
|
|
rr := RankedResult{
|
|
EventID: in.Event.ID,
|
|
CategoryID: in.Category.ID,
|
|
ChannelID: ch.ID,
|
|
Scope: ch.Scope,
|
|
Basis: ch.Basis,
|
|
TeamID: c.entry.primaryTeamID(),
|
|
Rank: g.startRank,
|
|
Points: pts,
|
|
}
|
|
if ch.Scope == ScopeTeam {
|
|
rr.TeamID = c.subject
|
|
rr.Shares = []TeamShare{{TeamID: c.subject, Weight: 1}}
|
|
} else {
|
|
rr.AthleteID = c.subject
|
|
rr.AthleteName = c.entry.AthleteName
|
|
rr.Shares = c.entry.resolvedShares(in.Options.UnionAttribution)
|
|
}
|
|
v := c.value
|
|
rr.ResultValue = &v
|
|
out = append(out, rr)
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func sortCandidatesByValue(cands []candidate, compare CompareMode) {
|
|
sort.SliceStable(cands, func(i, j int) bool {
|
|
if nearlyEqual(cands[i].value, cands[j].value) {
|
|
return cands[i].entry.ID < cands[j].entry.ID
|
|
}
|
|
if compare == CompareDesc {
|
|
return cands[i].value > cands[j].value
|
|
}
|
|
return cands[i].value < cands[j].value
|
|
})
|
|
}
|
|
|
|
func nearlyEqual(a, b float64) bool {
|
|
return math.Abs(a-b) <= rankEpsilon
|
|
}
|
|
|
|
// ledgerFromRanked 把名次明细转成积分流水：按通道 scope 决定记给个人还是单位，
|
|
// 联队按份额拆分；0 分不产生流水，避免流水表被零分噪声撑大。
|
|
func ledgerFromRanked(in EventScoreInput, ch ScoreChannel, ranked []RankedResult) []LedgerEntry {
|
|
var out []LedgerEntry
|
|
for _, rr := range ranked {
|
|
if rr.Points == 0 {
|
|
continue
|
|
}
|
|
athleteID := int64(0)
|
|
if rr.Scope == ScopeAthlete {
|
|
athleteID = rr.AthleteID
|
|
}
|
|
sourceID := rr.ResultID
|
|
if sourceID == 0 {
|
|
sourceID = rr.EntryID
|
|
}
|
|
if sourceID == 0 {
|
|
sourceID = ch.ID
|
|
}
|
|
for _, s := range rr.Shares {
|
|
pts := rr.Points * s.Weight
|
|
if pts == 0 {
|
|
continue
|
|
}
|
|
out = append(out, LedgerEntry{
|
|
TeamID: s.TeamID,
|
|
AthleteID: athleteID,
|
|
EventID: in.Event.ID,
|
|
CategoryID: in.Category.ID,
|
|
EntryID: rr.EntryID,
|
|
ResultID: rr.ResultID,
|
|
ChannelID: ch.ID,
|
|
SourceType: SourceResult,
|
|
SourceID: sourceID,
|
|
Points: pts,
|
|
})
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
// resolvedShares 解析报名项的归属：默认整体归主单位，联队模式才按份额拆分。
|
|
func (e Entry) resolvedShares(mode UnionAttribution) []TeamShare {
|
|
shares := e.teamShares()
|
|
if len(shares) == 0 {
|
|
return nil
|
|
}
|
|
if mode != UnionSplit {
|
|
return []TeamShare{{TeamID: e.primaryTeamID(), Weight: 1}}
|
|
}
|
|
return normalizeShares(shares)
|
|
}
|
|
|
|
// normalizeShares 把份额归一化到总和 1，避免配置里权重不标准导致总分被放大。
|
|
func normalizeShares(shares []TeamShare) []TeamShare {
|
|
var sum float64
|
|
for _, s := range shares {
|
|
sum += s.Weight
|
|
}
|
|
out := make([]TeamShare, len(shares))
|
|
if sum <= 0 {
|
|
w := 1 / float64(len(shares))
|
|
for i, s := range shares {
|
|
out[i] = TeamShare{TeamID: s.TeamID, Weight: w}
|
|
}
|
|
return out
|
|
}
|
|
for i, s := range shares {
|
|
out[i] = TeamShare{TeamID: s.TeamID, Weight: s.Weight / sum}
|
|
}
|
|
return out
|
|
}
|