package sniper import ( "context" "errors" "fmt" "math/rand" "sort" "strconv" "strings" "sync" "time" "huya-go/internal/huya" ) const ( CategoryReady = "ready" CategorySuccess = "success" CategoryNotFound = "not_found" CategoryNotOpen = "not_open" CategoryTooFrequent = "too_frequent" CategoryNotEnough = "not_enough" CategoryAlreadyDone = "already_done" CategoryOffShelf = "off_shelf" CategorySoldOut = "sold_out" CategoryFailed = "failed" CategoryError = "error" // CategoryCondition 表示服务端返回了 precondition 门禁(条件未达成), // 没有可识别文案,按可重试失败处理但单独分类便于观察。 CategoryCondition = "condition" // actionExchangeCanceled 表示申请并发额度时任务已被取消:这次请求根本没发出去, // 不应产出结果,否则停止监控时每个排队账号都会刷一条错误。 actionExchangeCanceled = "exchange_canceled" ) // CategoryText 把类目限制渲染成日志文案(空串表示不限类目)。 func CategoryText(category string) string { key := strings.TrimSpace(category) if key == "" { return "不限" } return key } // LogLevelForCategory 把结果分类映射成日志等级,供界面按等级高亮与筛选。 func LogLevelForCategory(category string) string { switch category { case CategorySuccess: return "success" case CategoryError: return "error" case CategoryFailed, CategoryTooFrequent, CategoryCondition: return "warn" default: return "info" } } type Account struct { UID int64 `json:"uid"` Cookie string `json:"-"` } type Target struct { PID int32 `json:"pid"` Name string `json:"name"` Auto bool `json:"auto,omitempty"` MaxPrice int64 `json:"max_price,omitempty"` MinLeft int64 `json:"min_left,omitempty"` } type Config struct { SID int32 // Category 限定只在某个类目(限量返场/精英专享,或类目 id)里挑选可兑奖品, // 留空表示不限制。见 huya.GetActPrizeListResp.FilterByCategory。 Category string Loops int Delay time.Duration Concurrency int StopAfterSuccess bool StopAccountAfterSuccess bool Prewarm bool DirectExchange bool ListBeforeExchange bool SharePrizeList bool RefreshAfterSuccess bool // StopOnNotEnough 表示「积分不足 / 已兑换」后终止该账号该奖品(默认 true: // 积分不会自己变多,继续打只是浪费请求)。 StopOnNotEnough bool ContinueOnNotEnough bool // StopOnSoldOut 表示「已抢完」后终止该奖品。默认 false:别人锁单未支付或取消 // 会让库存回流,窗口内应当继续低频探测(dygou_go 2026-10-03 实测结论)。 StopOnSoldOut bool TooFrequentBackoff time.Duration ErrorBackoff time.Duration } type Result struct { Loop int `json:"loop"` UID int64 `json:"uid"` TargetIndex int `json:"target_index,omitempty"` Target Target `json:"target"` Action string `json:"action"` Category string `json:"category,omitempty"` Message string `json:"message,omitempty"` Prize *huya.PrizeInfo `json:"prize,omitempty"` Exchange *huya.ScoreExchangePrizeResp `json:"exchange,omitempty"` Score *huya.GetUserScoreResp `json:"score,omitempty"` Records *huya.GetUserPrizeRecordsResp `json:"records,omitempty"` Done bool `json:"done,omitempty"` RetryAfter int64 `json:"retry_after,omitempty"` Error string `json:"error,omitempty"` } type Runner struct { Client huya.ActivityClient // OnSummary 在任务结束时回调一次汇总(可为 nil)。 // 汇总在成功后的异步刷新全部结束后才输出,因此能带上刷新产生的请求次数。 OnSummary func(RunSummary) } // RunSummary 汇总一次抢购任务的请求次数与结局分布,供日志复盘。 // 形状参考 dygou_go 的 logRunSummary:抢购结束后只打一行,替代逐条刷屏。 type RunSummary struct { Loops int Accounts int Targets int Duration time.Duration ListReqs int ExchangeReqs int ScoreReqs int RecordReqs int SuccessUIDs int Outcomes map[string]int } // Categories 按次数从多到少返回结局分类,次数相同时按名称排序,保证日志稳定。 func (s RunSummary) Categories() []string { names := make([]string, 0, len(s.Outcomes)) for name := range s.Outcomes { names = append(names, name) } sort.Slice(names, func(i, j int) bool { if s.Outcomes[names[i]] != s.Outcomes[names[j]] { return s.Outcomes[names[i]] > s.Outcomes[names[j]] } return names[i] < names[j] }) return names } type ActivityPrewarmer interface { PrewarmActivity(ctx context.Context, uid int64, cookie string, sid int32) error } type runState struct { mu sync.Mutex accounts map[int64][]targetState targetDone []bool // exchanged 记录每个账号已成功兑换的奖品,避免多个 target 命中同一奖品时重复兑换。 exchanged map[int64]map[int64]bool // refresh 用于等待成功后的异步刷新,确保 RunTargets 返回前不会提前释放连接。 refresh sync.WaitGroup // sem 是请求级并发闸门:一个额度对应一次在途请求,账号在退避等待期间 // 不再占用额度(参考 dygou_go runControl.enter)。旧实现把额度给整个账号 // 循环,退避中的账号会一直霸占额度,账号多时互相饿死。 sem chan struct{} // stats 记录请求次数与结局分布,任务结束时汇总成一行日志。 stats runStats } // runStats 是一次任务的运行统计。 type runStats struct { listReqs int exchangeReqs int scoreReqs int recordReqs int outcomes map[string]int successUIDs map[int64]bool } type targetState struct { Done bool RetryAfter time.Time } type listSnapshot struct { resp *huya.GetActPrizeListResp err error } func (r *Runner) Run(ctx context.Context, accounts []Account, target Target, cfg Config, emit func(Result)) error { return r.RunTargets(ctx, accounts, []Target{target}, cfg, emit) } func (r *Runner) RunTargets(ctx context.Context, accounts []Account, targets []Target, cfg Config, emit func(Result)) error { cfg = normalizeConfig(cfg) targets = normalizeTargets(targets) if len(accounts) == 0 { return errors.New("账号不能为空") } if len(targets) == 0 { return errors.New("目标奖品不能为空") } client := r.client() ctx, cancel := context.WithCancel(ctx) defer cancel() if cfg.Prewarm { if err := r.Prewarm(ctx, accounts, cfg, emit); err != nil { return err } } state := newRunState(accounts, len(targets), cfg.Concurrency) startedAt := time.Now() loopsRun := 0 // 成功后的刷新是异步的,等它们结束再返回,避免调用方提前关闭连接; // 汇总放在最后,才能把刷新产生的请求次数一起带上。 defer func() { state.refresh.Wait() r.emitSummary(state, len(accounts), len(targets), loopsRun, time.Since(startedAt)) }() for loop := 1; loop <= cfg.Loops; loop++ { loopsRun = loop if ctx.Err() != nil { return ctx.Err() } if state.allDone() { return nil } sharedList := r.sharedList(ctx, client, accounts, targets, cfg, state) var wg sync.WaitGroup for _, account := range accounts { account := account wg.Add(1) go func() { defer wg.Done() // 并发额度由每次请求自己申请(见 runState.acquire), // 账号在退避等待期间不占额度。 r.runAccountLoop(ctx, client, state, account, targets, cfg, loop, sharedList, emit, cancel) }() } wg.Wait() if ctx.Err() != nil { return ctx.Err() } if state.allDone() { return nil } if loop < cfg.Loops { if err := sleepContext(ctx, cfg.Delay); err != nil { return err } } } return nil } func (r *Runner) Prewarm(ctx context.Context, accounts []Account, cfg Config, emit func(Result)) error { cfg = normalizeConfig(cfg) if len(accounts) == 0 { return errors.New("账号不能为空") } client := r.client() prewarmer, ok := client.(ActivityPrewarmer) if !ok { return nil } sem := make(chan struct{}, cfg.Concurrency) var wg sync.WaitGroup for _, account := range accounts { account := account wg.Add(1) go func() { defer wg.Done() select { case sem <- struct{}{}: defer func() { <-sem }() case <-ctx.Done(): return } err := prewarmer.PrewarmActivity(ctx, account.UID, account.Cookie, cfg.SID) result := Result{ UID: account.UID, Action: "prewarm", Category: CategoryReady, Message: "连接已预热", } if err != nil { result.Category = CategoryError result.Error = err.Error() result.Message = "连接预热失败" } if emit != nil { emit(result) } }() } wg.Wait() return ctx.Err() } func (r *Runner) runAccountLoop(ctx context.Context, client huya.ActivityClient, state *runState, account Account, targets []Target, cfg Config, loop int, sharedList *listSnapshot, emit func(Result), cancel context.CancelFunc) { active := state.activeTargets(account.UID, len(targets), time.Now()) if len(active) == 0 { return } listTargets := make([]int, 0, len(active)) for _, index := range active { target := targets[index] if shouldDirectExchange(target, cfg) { // 直兑路径没有奖品列表,用 target.PID 判断是否已经兑换过同一奖品。 if state.prizeExchanged(account.UID, int64(target.PID)) { state.emitSkippedDuplicate(emit, loop, account.UID, index, target) continue } result := r.exchangeTarget(ctx, client, state, account, target, index, loop, cfg.SID, nil) if result.Action == actionExchangeCanceled { return } result = r.applyExchangeDecision(state, account, index, cfg, result, cancel) if result.Category == CategorySuccess { state.markPrizeExchanged(account.UID, int64(target.PID)) } if emit != nil { emit(result) } r.refreshAfterSuccess(state, client, account, target, index, loop, cfg, result, emit) if ctx.Err() != nil { return } continue } listTargets = append(listTargets, index) } if len(listTargets) == 0 || ctx.Err() != nil { return } list := sharedList if list == nil { if !state.acquire(ctx) { return } state.countRequest(reqList) resp, err := client.GetActPrizeList(ctx, account.UID, account.Cookie, cfg.SID) state.release() list = &listSnapshot{resp: resp, err: err} } if list.err != nil || list.resp == nil { errText := "奖品列表响应为空" if list.err != nil { errText = list.err.Error() } for _, index := range listTargets { retryAt := time.Now().Add(jitterDuration(cfg.ErrorBackoff)) state.setRetryAfter(account.UID, index, retryAt) state.recordOutcome(CategoryError) result := Result{ Loop: loop, UID: account.UID, TargetIndex: index, Target: targets[index], Action: "list_error", Category: CategoryError, Message: "查询奖品列表失败", RetryAfter: retryAt.UnixMilli(), Error: errText, } if emit != nil { emit(result) } } return } // 只按目标类目匹配:类目为空表示不限制(限量返场/精英专享都参与)。 prizes := list.resp.FilterByCategory(cfg.Category) for _, index := range listTargets { target := targets[index] prize := matchPrize(prizes, target) if prize == nil { state.recordOutcome(CategoryNotFound) result := Result{ Loop: loop, UID: account.UID, TargetIndex: index, Target: target, Action: "not_found", Category: CategoryNotFound, Message: notFoundMessage(cfg.Category), } if emit != nil { emit(result) } continue } // 多个 target 可能命中同一个奖品(例如按不同名称匹配),已成功兑换过就跳过。 if state.prizeExchanged(account.UID, prize.ID) { state.emitSkippedDuplicate(emit, loop, account.UID, index, target) continue } result := r.exchangeTarget(ctx, client, state, account, target, index, loop, cfg.SID, prize) if result.Action == actionExchangeCanceled { return } result = r.applyExchangeDecision(state, account, index, cfg, result, cancel) if result.Category == CategorySuccess { state.markPrizeExchanged(account.UID, prize.ID) } if emit != nil { emit(result) } r.refreshAfterSuccess(state, client, account, target, index, loop, cfg, result, emit) if ctx.Err() != nil { return } } } // emitSkippedDuplicate 在跳过同一奖品的重复兑换时给出明确结果,便于界面观察。 func (s *runState) emitSkippedDuplicate(emit func(Result), loop int, uid int64, index int, target Target) { s.recordOutcome(CategoryAlreadyDone) if emit == nil { return } emit(Result{ Loop: loop, UID: uid, TargetIndex: index, Target: target, Action: "skip_duplicate", Category: CategoryAlreadyDone, Message: "该奖品本账号已兑换成功,跳过重复兑换", }) } func (r *Runner) exchangeTarget(ctx context.Context, client huya.ActivityClient, state *runState, account Account, target Target, index int, loop int, sid int32, prize *huya.PrizeInfo) Result { pid := target.PID if prize != nil { pid = int32(prize.ID) } result := Result{ Loop: loop, UID: account.UID, TargetIndex: index, Target: target, Action: "exchange", Prize: prize, } if !state.acquire(ctx) { result.Action = actionExchangeCanceled result.Category = CategoryError result.Message = "任务已取消,未发起兑换" result.Error = ctx.Err().Error() return result } state.countRequest(reqExchange) exchange, err := client.ScoreExchangePrize(ctx, account.UID, account.Cookie, sid, pid) state.release() result.Exchange = exchange result.Category = ClassifyExchange(exchange, err) result.Message = ExchangeMessage(exchange) if err != nil { result.Action = "exchange_error" result.Error = err.Error() if result.Message == "" { result.Message = "兑换请求失败" } } return result } func (r *Runner) applyExchangeDecision(state *runState, account Account, index int, cfg Config, result Result, cancel context.CancelFunc) Result { now := time.Now() state.recordOutcome(result.Category) if result.Category == CategorySuccess { state.markSuccessUID(account.UID) } switch result.Category { case CategorySuccess: if cfg.StopAccountAfterSuccess { state.markDone(account.UID, index) result.Done = true } if cfg.StopAfterSuccess { cancel() } case CategoryNotEnough, CategoryAlreadyDone: if cfg.StopOnNotEnough { state.markDone(account.UID, index) result.Done = true } case CategoryOffShelf: // 已下架 / 奖品不存在:本窗口内不会再出现,直接终止该 target。 state.markTargetDone(index) result.Done = true case CategorySoldOut: if cfg.StopOnSoldOut { state.markTargetDone(index) result.Done = true } else { // 别人锁单未支付或取消会让库存回流,窗口内继续探测(只是放慢节奏)。 retryAt := now.Add(jitterDuration(cfg.ErrorBackoff)) state.setRetryAfter(account.UID, index, retryAt) result.RetryAfter = retryAt.UnixMilli() } case CategoryTooFrequent: retryAt := now.Add(jitterDuration(cfg.TooFrequentBackoff)) state.setRetryAfter(account.UID, index, retryAt) result.RetryAfter = retryAt.UnixMilli() case CategoryError, CategoryFailed, CategoryCondition: retryAt := now.Add(jitterDuration(cfg.ErrorBackoff)) state.setRetryAfter(account.UID, index, retryAt) result.RetryAfter = retryAt.UnixMilli() } return result } func (r *Runner) refreshAfterSuccess(state *runState, client huya.ActivityClient, account Account, target Target, index int, loop int, cfg Config, result Result, emit func(Result)) { if !cfg.RefreshAfterSuccess || emit == nil || result.Category != CategorySuccess { return } state.refresh.Add(1) go func() { defer state.refresh.Done() ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() // 刷新请求同样走并发闸门,但用拥有 5 秒预算的独立 ctx。 score, err := func() (*huya.GetUserScoreResp, error) { if !state.acquire(ctx) { return nil, ctx.Err() } defer state.release() state.countRequest(reqScore) return client.QueryUserScore(ctx, account.UID, account.Cookie, cfg.SID) }() scoreResult := Result{ Loop: loop, UID: account.UID, TargetIndex: index, Target: target, Action: "refresh_score", Category: CategoryReady, Message: "刷新积分完成", Score: score, } if err != nil { scoreResult.Category = CategoryError scoreResult.Message = "刷新积分失败" scoreResult.Error = err.Error() } else if score != nil { scoreResult.Message = fmt.Sprintf("剩余积分: %d", score.AvailableScore()) } emit(scoreResult) records, err := func() (*huya.GetUserPrizeRecordsResp, error) { if !state.acquire(ctx) { return nil, ctx.Err() } defer state.release() state.countRequest(reqRecord) return client.GetUserPrizeRecords(ctx, account.UID, account.Cookie, cfg.SID) }() recordResult := Result{ Loop: loop, UID: account.UID, TargetIndex: index, Target: target, Action: "refresh_records", Category: CategoryReady, Message: "刷新兑换记录完成", Records: records, } if err != nil { recordResult.Category = CategoryError recordResult.Message = "刷新兑换记录失败" recordResult.Error = err.Error() } emit(recordResult) }() } func (r *Runner) sharedList(ctx context.Context, client huya.ActivityClient, accounts []Account, targets []Target, cfg Config, state *runState) *listSnapshot { if !cfg.SharePrizeList || len(accounts) == 0 { return nil } needsList := false for _, account := range accounts { for _, index := range state.activeTargets(account.UID, len(targets), time.Now()) { if !shouldDirectExchange(targets[index], cfg) { needsList = true break } } if needsList { break } } if !needsList { return nil } if !state.acquire(ctx) { return &listSnapshot{err: ctx.Err()} } state.countRequest(reqList) resp, err := client.GetActPrizeList(ctx, accounts[0].UID, accounts[0].Cookie, cfg.SID) state.release() return &listSnapshot{resp: resp, err: err} } func (r *Runner) client() huya.ActivityClient { if r.Client != nil { return r.Client } return huya.NewHTTPClient(nil) } func newRunState(accounts []Account, targetCount, concurrency int) *runState { if concurrency <= 0 { concurrency = 1 } state := &runState{ accounts: make(map[int64][]targetState, len(accounts)), targetDone: make([]bool, targetCount), exchanged: make(map[int64]map[int64]bool, len(accounts)), sem: make(chan struct{}, concurrency), stats: runStats{ outcomes: map[string]int{}, successUIDs: map[int64]bool{}, }, } for _, account := range accounts { state.accounts[account.UID] = make([]targetState, targetCount) } return state } // requestKind 标识一次在途请求的类型,用于汇总日志里的请求次数。 type requestKind int const ( reqList requestKind = iota reqExchange reqScore reqRecord ) // acquire 申请一个请求额度;ctx 结束时会返回 false,调用方应直接放弃这次请求。 func (s *runState) acquire(ctx context.Context) bool { if s.sem == nil { return ctx.Err() == nil } select { case s.sem <- struct{}{}: return true case <-ctx.Done(): return false } } func (s *runState) release() { if s.sem == nil { return } <-s.sem } func (s *runState) countRequest(kind requestKind) { s.mu.Lock() defer s.mu.Unlock() switch kind { case reqList: s.stats.listReqs++ case reqExchange: s.stats.exchangeReqs++ case reqScore: s.stats.scoreReqs++ case reqRecord: s.stats.recordReqs++ } } // recordOutcome 累计一条结局分类,供任务结束时的汇总日志使用。 func (s *runState) recordOutcome(category string) { if category == "" { return } s.mu.Lock() defer s.mu.Unlock() if s.stats.outcomes == nil { s.stats.outcomes = map[string]int{} } s.stats.outcomes[category]++ } func (s *runState) markSuccessUID(uid int64) { s.mu.Lock() defer s.mu.Unlock() if s.stats.successUIDs == nil { s.stats.successUIDs = map[int64]bool{} } s.stats.successUIDs[uid] = true } func (s *runState) snapshotStats() runStats { s.mu.Lock() defer s.mu.Unlock() out := runStats{ listReqs: s.stats.listReqs, exchangeReqs: s.stats.exchangeReqs, scoreReqs: s.stats.scoreReqs, recordReqs: s.stats.recordReqs, outcomes: make(map[string]int, len(s.stats.outcomes)), successUIDs: make(map[int64]bool, len(s.stats.successUIDs)), } for key, value := range s.stats.outcomes { out.outcomes[key] = value } for uid := range s.stats.successUIDs { out.successUIDs[uid] = true } return out } // emitSummary 在任务结束时回调一次汇总;OnSummary 为 nil 时不做任何事。 func (r *Runner) emitSummary(state *runState, accounts, targets, loops int, cost time.Duration) { if r.OnSummary == nil { return } stats := state.snapshotStats() r.OnSummary(RunSummary{ Loops: loops, Accounts: accounts, Targets: targets, Duration: cost, ListReqs: stats.listReqs, ExchangeReqs: stats.exchangeReqs, ScoreReqs: stats.scoreReqs, RecordReqs: stats.recordReqs, SuccessUIDs: len(stats.successUIDs), Outcomes: stats.outcomes, }) } // prizeExchanged 判断该账号是否已经成功兑换过这个奖品。 func (s *runState) prizeExchanged(uid, prizeID int64) bool { if prizeID <= 0 { return false } s.mu.Lock() defer s.mu.Unlock() return s.exchanged[uid][prizeID] } func (s *runState) markPrizeExchanged(uid, prizeID int64) { if prizeID <= 0 { return } s.mu.Lock() defer s.mu.Unlock() if s.exchanged[uid] == nil { s.exchanged[uid] = map[int64]bool{} } s.exchanged[uid][prizeID] = true } func (s *runState) activeTargets(uid int64, targetCount int, now time.Time) []int { s.mu.Lock() defer s.mu.Unlock() items := s.accounts[uid] active := make([]int, 0, targetCount) for i := 0; i < targetCount; i++ { if i < len(s.targetDone) && s.targetDone[i] { continue } if i >= len(items) || items[i].Done { continue } if !items[i].RetryAfter.IsZero() && items[i].RetryAfter.After(now) { continue } active = append(active, i) } return active } func (s *runState) markDone(uid int64, index int) { s.mu.Lock() defer s.mu.Unlock() if items := s.accounts[uid]; index >= 0 && index < len(items) { items[index].Done = true items[index].RetryAfter = time.Time{} s.accounts[uid] = items } } func (s *runState) markTargetDone(index int) { s.mu.Lock() defer s.mu.Unlock() if index >= 0 && index < len(s.targetDone) { s.targetDone[index] = true } } func (s *runState) setRetryAfter(uid int64, index int, when time.Time) { s.mu.Lock() defer s.mu.Unlock() if items := s.accounts[uid]; index >= 0 && index < len(items) { items[index].RetryAfter = when s.accounts[uid] = items } } func (s *runState) allDone() bool { s.mu.Lock() defer s.mu.Unlock() for index, globallyDone := range s.targetDone { if globallyDone { continue } for _, items := range s.accounts { if index < len(items) && !items[index].Done { return false } } } return true } func normalizeConfig(cfg Config) Config { cfg.Category = strings.TrimSpace(cfg.Category) if cfg.Loops <= 0 { cfg.Loops = 1 } if cfg.Delay <= 0 { cfg.Delay = 150 * time.Millisecond } if cfg.Concurrency <= 0 { cfg.Concurrency = 1 } if cfg.TooFrequentBackoff <= 0 { cfg.TooFrequentBackoff = maxDuration(cfg.Delay*2, 300*time.Millisecond) } if cfg.ErrorBackoff <= 0 { cfg.ErrorBackoff = maxDuration(cfg.Delay, 300*time.Millisecond) } // 积分不足是终态:积分不会自己变多,继续打只是浪费请求,默认停手。 if !cfg.ContinueOnNotEnough { cfg.StopOnNotEnough = true } // 售罄刻意不给默认值:库存可能因别人取消 / 锁单过期而回流,默认继续探测到 // 循环结束;需要「售罄即停」时显式设置 StopOnSoldOut。 if !cfg.ListBeforeExchange { cfg.DirectExchange = true } return cfg } // normalizeTargets 去掉空目标与重复目标。 // // 除了完全相同的 target,还按 pid / 名称去重:界面选品会同时提交 pid、名称, // 以及 targetText 里的同一个 pid,不去重就会对同一奖品重复兑换(实测踩过)。 func normalizeTargets(targets []Target) []Target { out := make([]Target, 0, len(targets)) seenKey := map[string]bool{} seenPID := map[int32]bool{} seenName := map[string]bool{} for _, target := range targets { target.Name = strings.TrimSpace(target.Name) if target.PID <= 0 && target.Name == "" && !target.Auto { continue } if target.PID > 0 && seenPID[target.PID] { continue } if target.Name != "" && seenName[target.Name] { continue } key := targetKey(target) if seenKey[key] { continue } seenKey[key] = true if target.PID > 0 { seenPID[target.PID] = true } if target.Name != "" { seenName[target.Name] = true } out = append(out, target) } return out } func shouldDirectExchange(target Target, cfg Config) bool { return cfg.DirectExchange && !cfg.ListBeforeExchange && target.PID > 0 && !target.Auto } // notFoundMessage 在未命中时把类目限制写进提示,便于区分「被类目过滤掉」与「列表里确实没有」。 func notFoundMessage(category string) string { if strings.TrimSpace(category) == "" { return "未查询到所需物品,继续监控" } return fmt.Sprintf("类目[%s]内未查询到所需物品,继续监控", strings.TrimSpace(category)) } func matchPrize(prizes []huya.PrizeInfo, target Target) *huya.PrizeInfo { if target.Auto { return autoPrize(prizes, target) } for i := range prizes { if target.PID > 0 && int32(prizes[i].ID) != target.PID { continue } if target.PID == 0 && target.Name != "" && !strings.Contains(prizes[i].Name, target.Name) { continue } if target.MaxPrice > 0 && prizes[i].Price() > target.MaxPrice { continue } if target.MinLeft > 0 && prizes[i].EstimatedLeft() < target.MinLeft { continue } return &prizes[i] } return nil } func autoPrize(prizes []huya.PrizeInfo, target Target) *huya.PrizeInfo { var fallback *huya.PrizeInfo for i := range prizes { if target.MaxPrice > 0 && prizes[i].Price() > target.MaxPrice { continue } if target.MinLeft > 0 && prizes[i].EstimatedLeft() < target.MinLeft { continue } if fallback == nil { fallback = &prizes[i] } if prizes[i].EstimatedLeft() > 0 { return &prizes[i] } } return fallback } // exchangeSignals 汇总一次兑换响应里可用于判定的信号。 // // 虎牙把失败原因分散在 msg / actPreCondition(Tip/ButtonDesc/ConditionParams) // 和 exchangeInfo.desc 里,status 除 200 外没有可依据的公开语义, // 所以判定顺序是:文案 -> 成功结构(status=200 且有 orderId)-> 结构门禁 -> 兜底失败。 type exchangeSignals struct { text string status int32 hasOrderID bool conditionType int32 } func buildExchangeSignals(resp *huya.ScoreExchangePrizeResp) exchangeSignals { if resp == nil { return exchangeSignals{} } parts := []string{ resp.Msg, resp.ActPreCondition.Tip, resp.ActPreCondition.ButtonDesc, resp.ExchangeInfo.Desc, } for _, value := range resp.ActPreCondition.ConditionParams { parts = append(parts, value) } texts := make([]string, 0, len(parts)) for _, part := range parts { if item := strings.TrimSpace(part); item != "" { texts = append(texts, item) } } return exchangeSignals{ text: strings.Join(texts, " "), status: resp.Status, hasOrderID: strings.TrimSpace(resp.OrderID) != "", conditionType: resp.ActPreCondition.ConditionType, } } // classifyExchangeText 只依据文案判定失败原因,命中时返回分类。 func classifyExchangeText(text string) (string, bool) { switch { case containsAny(text, "操作频繁", "太频繁", "稍后再试"): return CategoryTooFrequent, true case containsAny(text, "暂未开放", "未开放", "未开始", "活动未开始"): return CategoryNotOpen, true case containsAny(text, "已抢完", "已兑完", "库存不足", "没有库存", "领完了"): return CategorySoldOut, true case containsAny(text, "货币不足", "积分不足", "余额不足", "点券不足", "不足"): return CategoryNotEnough, true case containsAny(text, "已兑换", "重复兑换", "已领取", "超过兑换次数", "达到上限", "限购"): return CategoryAlreadyDone, true case containsAny(text, "奖品已下架", "已下架", "奖品不存在", "活动不存在"): return CategoryOffShelf, true } return "", false } func ClassifyExchange(resp *huya.ScoreExchangePrizeResp, err error) string { if err != nil { return CategoryError } if resp == nil { return CategoryFailed } if resp.Success() { return CategorySuccess } signals := buildExchangeSignals(resp) if category, ok := classifyExchangeText(signals.text); ok { return category } // 成功回包也可能不带中文文案:status=200 且有 orderId 视为成功。 if signals.status == 200 && signals.hasOrderID { return CategorySuccess } // 没有文案但服务端回了 precondition 门禁,归为条件未达成,按可重试失败处理。 if signals.conditionType != 0 { return CategoryCondition } return CategoryFailed } // ExchangeMessage 返回响应里最有代表性的提示文案,供日志与 GUI 展示。 func ExchangeMessage(resp *huya.ScoreExchangePrizeResp) string { if resp == nil { return "" } for _, text := range []string{ resp.Msg, resp.ActPreCondition.Tip, resp.ActPreCondition.ButtonDesc, resp.ExchangeInfo.Desc, } { if strings.TrimSpace(text) != "" { return strings.TrimSpace(text) } } return "" } func containsAny(text string, needles ...string) bool { for _, needle := range needles { if strings.Contains(text, needle) { return true } } return false } func targetKey(target Target) string { return strings.Join([]string{ strings.TrimSpace(target.Name), int32String(target.PID), strconv.FormatBool(target.Auto), int64String(target.MaxPrice), int64String(target.MinLeft), }, "\x00") } func int32String(value int32) string { return strconv.FormatInt(int64(value), 10) } func int64String(value int64) string { return strconv.FormatInt(value, 10) } func sleepContext(ctx context.Context, d time.Duration) error { timer := time.NewTimer(d) defer timer.Stop() select { case <-timer.C: return nil case <-ctx.Done(): return ctx.Err() } } func maxDuration(a, b time.Duration) time.Duration { if a > b { return a } return b } // jitterDuration 在基准退避上叠加 0-25% 的随机抖动。 // // 多个账号同时失败时,固定退避会让它们在同一个时刻整批重试,形成周期性尖峰, // 更容易撞上限频(参考 dygou_go 的 jitterFraction)。这里只往长了抖,不缩短, // 保证配置值始终是退避下限。 func jitterDuration(base time.Duration) time.Duration { if base <= 0 { return base } span := int64(base) / 4 if span <= 0 { return base } return base + time.Duration(rand.Int63n(span+1)) }