s_cherry_e/sr/nodes/game/player/quest/service.go

package quest

import (
	"f1-game/internal/data"
	"f1-game/internal/enum"
	"f1-game/internal/facade"
	nameRoute "f1-game/internal/name/route"
	"f1-game/internal/pb"
	"f1-game/internal/sessions"
	"f1-game/nodes/game/internal/db"
	dbQuest "f1-game/nodes/game/internal/db/data/quest"
	"slices"

	ctime "github.com/cherry-game/cherry/extend/time"
	cfacade "github.com/cherry-game/cherry/facade"
	cactor "github.com/cherry-game/cherry/net/actor"
	cproto "github.com/cherry-game/cherry/net/proto"

	clog "github.com/cherry-game/cherry/logger"
)

var srv = &service{
	groupOpen: newServiceGroupOpen(),
	typ:       newServiceType(),
}

func Service() *service {
	return srv
}

type service struct {
	facade.PlayerServiceBase[*db.PlayerTable]
	typ       serviceType
	groupOpen serviceGroupOpen
}

func (p *service) OnLogin(playerTable *db.PlayerTable, _ *cproto.Session) {
	questTable := db.GetQuestTable(playerTable.PlayerID)
	for _, quest := range questTable.Quests {
		if quest.Status != enum.QuestStatus_Running {
			continue
		}

		row, ok := data.Quest.GetByQuestGroupIDQuestID(quest.QuestGroupID, quest.QuestID)
		if !ok {
			continue
		}

		if len(row.QuestParams) < 1 {
			clog.Warnf("[OnLogin] quest params is empty. playerID = %d, questID = %d", playerTable.PlayerID, quest.QuestID)
			continue
		}

		quest.CheckDataFinish(row.QuestParams[0])
	}
}

// func (p *service) OnLogined(playerTable *db.PlayerTable, _ *cproto.Session) {
// }

// func (p *service) OnLogout(playerTable *db.PlayerTable) {
// }

func (p *service) OnReset(playerTable *db.PlayerTable, _ *ctime.CherryTime, byLogin bool) {
	if !playerTable.Stats.IsCanReset() {
		return
	}

	var (
		questTable = db.GetQuestTable(playerTable.PlayerID)
		delIDList  []int32
	)

	for _, questEntity := range questTable.Quests {
		groupRow, found := data.QuestGroup.GetByGroupID(questEntity.QuestGroupID)

		// 删除配表找不到的任务
		if !found {
			delIDList = append(delIDList, questEntity.QuestID)
			continue
		}

		// 删除 日循环任务
		if playerTable.Stats.IsDayReset && groupRow.ResetType == enum.QuestResetType_HourOfDay {
			delIDList = append(delIDList, questEntity.QuestID)
			continue
		}

		// 删除 周循环任务
		if playerTable.Stats.IsWeekReset && groupRow.ResetType == enum.QuestResetType_DayOfWeek {
			delIDList = append(delIDList, questEntity.QuestID)
			continue
		}
	}

	if len(delIDList) > 0 {
		questTable.DeleteQuests(delIDList)
		questTable.Save2Queue()
	}

	// 重置检查是否有新任务
	p.checkQuestReset(playerTable.PlayerID)
}

func (p *service) Push(playerTable *db.PlayerTable, session *cproto.Session) {
	questTable := db.GetQuestTable(playerTable.PlayerID)
	p.ChangePushWithSession(session, questTable.List())
}

func (p *service) ChangePush(playerID int64, changeList []*dbQuest.Quest) {
	session, found := sessions.GetSession(playerID)
	if !found {
		clog.Warnf("[ChangePushWithPlayerID] session not found. [playerID = %d]", playerID)
		return
	}

	p.ChangePushWithSession(session, changeList)
}

// ChangePush 推送任务变更列表
func (p *service) ChangePushWithSession(session *cproto.Session, changeList []*dbQuest.Quest) {
	if len(changeList) < 1 {
		return
	}

	push := &pb.QuestList{}

	for _, quest := range changeList {
		protoQuest := quest.ToProto()
		push.Quests = append(push.Quests, &protoQuest)
	}

	sessions.PushWithSession(session, nameRoute.PushGamePlayer_Quests, push)
}

// CheckNewAndPush 检查是否有新的任务组&推送
func (p *service) checkQuestReset(playerID int64) {
	var (
		questTable = db.GetQuestTable(playerID)
		groupRows  = []*data.QuestGroupRow{}
	)

	// 遍历配置,获取是否有新增加的任务&组
	for _, groupRow := range data.QuestGroup.List() {
		// 功能触发类型的跳过
		if groupRow.OpenType == enum.QuestOpenType_TriggerOpen {
			continue
		}

		//验证本组是否开放
		if !p.groupOpen.validate(groupRow.OpenType, playerID, groupRow) {
			continue
		}

		// 添加满足的任务组配置
		groupRows = append(groupRows, groupRow)
	}

	// 添加本组的任务
	p.AddQuestWithGroups(questTable, groupRows...)
}

// AddQuestWithGroups 根据任务组添加任务列表
func (p *service) AddQuestWithGroups(questTable *db.QuestTable, groupRows ...*data.QuestGroupRow) bool {
	if len(groupRows) < 1 {
		return false
	}

	changeList := []*dbQuest.Quest{}
	for _, groupRow := range groupRows {
		questRows, found := data.Quest.ListByQuestGroupID(groupRow.GroupID)
		if !found {
			clog.Warnf("add quest with group fail, quest config not found. playerID:%d", questTable.PlayerID)
			continue
		}

		for _, newQuestRow := range questRows {
			// 当前任务禁用， 跳过
			if newQuestRow.Disabled {
				continue
			}

			newQuestEntity, ok := p.AddQuest(questTable, newQuestRow)
			if !ok {
				continue
			}

			changeList = append(changeList, newQuestEntity)
		}
	}

	if len(changeList) < 1 {
		return false
	}

	// 保存任务数据
	questTable.Save2Queue()

	// 推送给客户端
	p.ChangePush(questTable.PlayerID, changeList)

	return true
}

// // AddQuest 添加一个任务
func (p *service) AddQuest(questTable *db.QuestTable, questRow *data.QuestRow) (*dbQuest.Quest, bool) {
	if questRow == nil {
		clog.Warnf("quest is nil. [config = %+v]", questRow)
		return nil, false
	}

	if questRow.QuestType < 1 {
		clog.Warnf("quest type error. [config = %+v]", questRow)
		return nil, false
	}

	if questTable.ContainQuest(questRow.QuestID) {
		return nil, false
	}

	if len(questRow.QuestParams) < 1 {
		clog.Warnf("quest params is empty. [config = %+v]", questRow)
		return nil, false
	}

	// 获取任务类型解析器
	parser, found := p.typ.get(questRow.QuestType)
	if !found {
		clog.Warnf("quest type not implemented. [config = %+v]", questRow)
		return nil, false
	}

	// 创建任务
	newQuestEntity := dbQuest.NewQuest(questRow.QuestGroupID, questRow.QuestID)
	if !parser.OnCreate(questTable.PlayerID, &newQuestEntity, questRow) {
		clog.Warnf("create new questID fail. [questID = %d]", questRow.QuestID)
		return nil, false
	}

	// 检查任务是否完成
	newQuestEntity.CheckDataFinish(questRow.QuestParams[0])

	// 添加任务到存储
	isAdd := questTable.AddQuest(&newQuestEntity)
	return &newQuestEntity, isAdd
}

// TriggerOpenGroup 触发添加任务组(手工调用该函数)
func (p *service) TriggerOpenGroup(playerID int64, groupID int32) bool {
	questTable := db.GetQuestTable(playerID)
	if questTable.ContainGroup(groupID) {
		return false
	}

	groupRow, found := data.QuestGroup.GetByGroupID(groupID)
	if !found {
		return false
	}

	if groupRow.OpenType != enum.QuestOpenType_TriggerOpen {
		clog.Infof("[playerID = %d] [groupID = %d] openType != trigger open")
		return false
	}

	// 添加任务
	return p.AddQuestWithGroups(questTable, groupRow)
}

func (p *service) InitEvents(event cactor.IEvent, playerID int64) {
	event.Registers(p.typ.eventNames(), p.onEvent, playerID)
}

func (p *service) onEvent(e cfacade.IEventData) {
	var (
		playerID   = e.UniqueID()
		questTable = db.GetQuestTable(playerID) // quest table
		changeList []*dbQuest.Quest             // 任务变更列表
	)

	for _, questEntity := range questTable.Quests {
		// 已完成或已结束的任务 则跳过
		if questEntity.IsFinish() {
			continue
		}

		// 获取任务配置
		questRow, found := data.Quest.GetByQuestGroupIDQuestID(questEntity.QuestGroupID, questEntity.QuestID)
		if !found {
			clog.Warnf("[playerID = %d, quest = %+v] quest config not found.", playerID, questEntity)
			continue
		}

		parser, found := p.typ.get(questRow.QuestType)
		if !found {
			clog.Warnf("[playerID = %d, quest = %+v] quest type not found.", playerID, questRow)
			continue
		}

		if !slices.Contains(parser.EventNames(), e.Name()) {
			continue
		}

		// 通过事件更新任务数据
		if parser.OnUpdate(playerID, questEntity, questRow, e) {
			// add to change list
			changeList = append(changeList, questEntity)

			// 检查是否完成
			questEntity.CheckDataFinish(questRow.QuestParams[0])
		}
	}

	if len(changeList) > 0 {
		// 推送变更数据
		questTable.Save2Queue()

		// 推送任务列表
		p.ChangePush(playerID, changeList)
	}
}