Implement Fate Boards

server/internal/masterdata/labyrinth.go

@@ -0,0 +1,225 @@
+package masterdata
+
+import (
+	"log"
+	"sort"
+
+	"lunar-tear/server/internal/utils"
+)
+
+type LabyrinthChapter struct {
+	EventQuestChapterId int32
+	LatestSeasonNumber  int32
+	StageOrders         []int32
+}
+
+type LabyrinthStageTier struct {
+	QuestMissionClearCount int32
+	Rewards                []RewardItem
+}
+
+type LabyrinthSeasonMilestone struct {
+	HeadQuestId    int32
+	HeadStageOrder int32
+	Rewards        []RewardItem
+}
+
+type labyrinthStageKey struct {
+	ChapterId  int32
+	StageOrder int32
+}
+
+type LabyrinthCatalog struct {
+	ChaptersByOrder           []LabyrinthChapter
+	ClearRewardsByStage       map[labyrinthStageKey][]RewardItem
+	AccumTiersByStage         map[labyrinthStageKey][]LabyrinthStageTier
+	SeasonMilestonesByChapter map[int32][]LabyrinthSeasonMilestone
+}
+
+func (c *LabyrinthCatalog) StageClearReward(chapterId, stageOrder int32) []RewardItem {
+	return c.ClearRewardsByStage[labyrinthStageKey{chapterId, stageOrder}]
+}
+
+func (c *LabyrinthCatalog) CollectAccumulationRewards(chapterId, stageOrder, oldCount, targetCount int32) ([]RewardItem, int32) {
+	var items []RewardItem
+	highest := int32(0)
+	for _, t := range c.AccumTiersByStage[labyrinthStageKey{chapterId, stageOrder}] {
+		if t.QuestMissionClearCount > oldCount && t.QuestMissionClearCount <= targetCount {
+			items = append(items, t.Rewards...)
+			if t.QuestMissionClearCount > highest {
+				highest = t.QuestMissionClearCount
+			}
+		}
+	}
+	return items, highest
+}
+
+func (c *LabyrinthCatalog) SeasonMilestones(chapterId int32) []LabyrinthSeasonMilestone {
+	return c.SeasonMilestonesByChapter[chapterId]
+}
+
+func LoadLabyrinthCatalog() *LabyrinthCatalog {
+	seasonRows, err := utils.ReadTable[EntityMEventQuestLabyrinthSeason]("m_event_quest_labyrinth_season")
+	if err != nil {
+		log.Printf("[labyrinth] m_event_quest_labyrinth_season unavailable, labyrinth disabled: %v", err)
+		return &LabyrinthCatalog{}
+	}
+	stageRows, err := utils.ReadTable[EntityMEventQuestLabyrinthStage]("m_event_quest_labyrinth_stage")
+	if err != nil {
+		log.Printf("[labyrinth] m_event_quest_labyrinth_stage unavailable, labyrinth disabled: %v", err)
+		return &LabyrinthCatalog{}
+	}
+
+	// chapterId -> highest SeasonNumber
+	latestSeason := make(map[int32]int32)
+	for _, r := range seasonRows {
+		if r.SeasonNumber > latestSeason[r.EventQuestChapterId] {
+			latestSeason[r.EventQuestChapterId] = r.SeasonNumber
+		}
+	}
+	// chapterId -> stage orders
+	stagesByChapter := make(map[int32][]int32)
+	for _, r := range stageRows {
+		stagesByChapter[r.EventQuestChapterId] = append(stagesByChapter[r.EventQuestChapterId], r.StageOrder)
+	}
+
+	chapters := make([]LabyrinthChapter, 0, len(latestSeason))
+	for chapterId, season := range latestSeason {
+		stages := stagesByChapter[chapterId]
+		sort.Slice(stages, func(i, j int) bool { return stages[i] < stages[j] })
+		chapters = append(chapters, LabyrinthChapter{
+			EventQuestChapterId: chapterId,
+			LatestSeasonNumber:  season,
+			StageOrders:         stages,
+		})
+	}
+	sort.Slice(chapters, func(i, j int) bool {
+		return chapters[i].EventQuestChapterId < chapters[j].EventQuestChapterId
+	})
+
+	clearRewards, accumTiers, seasonMilestones := loadLabyrinthRewards(seasonRows, stageRows)
+
+	log.Printf("labyrinth catalog loaded: %d chapters, %d stages with clear rewards, %d with accumulation rewards, %d chapters with season rewards",
+		len(chapters), len(clearRewards), len(accumTiers), len(seasonMilestones))
+	return &LabyrinthCatalog{
+		ChaptersByOrder:           chapters,
+		ClearRewardsByStage:       clearRewards,
+		AccumTiersByStage:         accumTiers,
+		SeasonMilestonesByChapter: seasonMilestones,
+	}
+}
+
+func loadLabyrinthRewards(seasonRows []EntityMEventQuestLabyrinthSeason, stageRows []EntityMEventQuestLabyrinthStage) (
+	clearRewards map[labyrinthStageKey][]RewardItem,
+	accumTiers map[labyrinthStageKey][]LabyrinthStageTier,
+	seasonMilestones map[int32][]LabyrinthSeasonMilestone,
+) {
+	rewardGroupRows, err := utils.ReadTable[EntityMEventQuestLabyrinthRewardGroup]("m_event_quest_labyrinth_reward_group")
+	if err != nil {
+		log.Printf("[labyrinth] m_event_quest_labyrinth_reward_group unavailable, rewards disabled: %v", err)
+		return nil, nil, nil
+	}
+
+	// reward group id -> reward items
+	itemsByRewardGroup := make(map[int32][]RewardItem)
+	for _, r := range rewardGroupRows {
+		itemsByRewardGroup[r.EventQuestLabyrinthRewardGroupId] = append(itemsByRewardGroup[r.EventQuestLabyrinthRewardGroupId], RewardItem{
+			PossessionType: r.PossessionType,
+			PossessionId:   r.PossessionId,
+			Count:          r.Count,
+		})
+	}
+
+	// per-stage one-time clear reward
+	clearRewards = make(map[labyrinthStageKey][]RewardItem)
+	for _, r := range stageRows {
+		if r.StageClearRewardGroupId == 0 {
+			continue
+		}
+		if items := itemsByRewardGroup[r.StageClearRewardGroupId]; len(items) > 0 {
+			clearRewards[labyrinthStageKey{r.EventQuestChapterId, r.StageOrder}] = items
+		}
+	}
+
+	if accumGroupRows, err := utils.ReadTable[EntityMEventQuestLabyrinthStageAccumulationRewardGroup]("m_event_quest_labyrinth_stage_accumulation_reward_group"); err != nil {
+		log.Printf("[labyrinth] m_event_quest_labyrinth_stage_accumulation_reward_group unavailable, accumulation rewards disabled: %v", err)
+	} else {
+		// accumulation group id -> tiers (threshold + resolved reward items)
+		tiersByGroup := make(map[int32][]LabyrinthStageTier)
+		for _, r := range accumGroupRows {
+			tiersByGroup[r.EventQuestLabyrinthStageAccumulationRewardGroupId] = append(tiersByGroup[r.EventQuestLabyrinthStageAccumulationRewardGroupId], LabyrinthStageTier{
+				QuestMissionClearCount: r.QuestMissionClearCount,
+				Rewards:                itemsByRewardGroup[r.EventQuestLabyrinthRewardGroupId],
+			})
+		}
+		accumTiers = make(map[labyrinthStageKey][]LabyrinthStageTier)
+		for _, r := range stageRows {
+			if r.StageAccumulationRewardGroupId == 0 {
+				continue
+			}
+			tiers := tiersByGroup[r.StageAccumulationRewardGroupId]
+			sort.Slice(tiers, func(i, j int) bool {
+				return tiers[i].QuestMissionClearCount < tiers[j].QuestMissionClearCount
+			})
+			accumTiers[labyrinthStageKey{r.EventQuestChapterId, r.StageOrder}] = tiers
+		}
+	}
+
+	// per-chapter season-reward milestones
+	if seasonRewardRows, err := utils.ReadTable[EntityMEventQuestLabyrinthSeasonRewardGroup]("m_event_quest_labyrinth_season_reward_group"); err != nil {
+		log.Printf("[labyrinth] m_event_quest_labyrinth_season_reward_group unavailable, season rewards disabled: %v", err)
+	} else {
+		seasonMilestones = buildLabyrinthSeasonMilestones(seasonRows, seasonRewardRows, itemsByRewardGroup)
+	}
+
+	return clearRewards, accumTiers, seasonMilestones
+}
+
+func buildLabyrinthSeasonMilestones(
+	seasonRows []EntityMEventQuestLabyrinthSeason,
+	seasonRewardRows []EntityMEventQuestLabyrinthSeasonRewardGroup,
+	itemsByRewardGroup map[int32][]RewardItem,
+) map[int32][]LabyrinthSeasonMilestone {
+	// chapter -> SeasonRewardGroupId (all seasons of a chapter share one)
+	groupByChapter := make(map[int32]int32)
+	for _, r := range seasonRows {
+		groupByChapter[r.EventQuestChapterId] = r.SeasonRewardGroupId
+	}
+	// SeasonRewardGroupId -> its rows, in table order
+	rowsByGroup := make(map[int32][]EntityMEventQuestLabyrinthSeasonRewardGroup)
+	for _, r := range seasonRewardRows {
+		rowsByGroup[r.EventQuestLabyrinthSeasonRewardGroupId] = append(rowsByGroup[r.EventQuestLabyrinthSeasonRewardGroupId], r)
+	}
+
+	milestones := make(map[int32][]LabyrinthSeasonMilestone)
+	for chapterId, seasonGroupId := range groupByChapter {
+		rows := rowsByGroup[seasonGroupId]
+		if len(rows) == 0 {
+			continue
+		}
+		// rank distinct reward-group ids ascending -> 1-based head stage order
+		stageByRewardGroup := make(map[int32]int32)
+		var distinct []int32
+		for _, r := range rows {
+			if _, seen := stageByRewardGroup[r.EventQuestLabyrinthRewardGroupId]; !seen {
+				stageByRewardGroup[r.EventQuestLabyrinthRewardGroupId] = 0
+				distinct = append(distinct, r.EventQuestLabyrinthRewardGroupId)
+			}
+		}
+		sort.Slice(distinct, func(i, j int) bool { return distinct[i] < distinct[j] })
+		for i, gid := range distinct {
+			stageByRewardGroup[gid] = int32(i + 1)
+		}
+
+		list := make([]LabyrinthSeasonMilestone, 0, len(rows))
+		for _, r := range rows {
+			list = append(list, LabyrinthSeasonMilestone{
+				HeadQuestId:    r.HeadQuestId,
+				HeadStageOrder: stageByRewardGroup[r.EventQuestLabyrinthRewardGroupId],
+				Rewards:        itemsByRewardGroup[r.EventQuestLabyrinthRewardGroupId],
+			})
+		}
+		milestones[chapterId] = list
+	}
+	return milestones
+}