go_dreamfactory/modules/rtask/verifyHandle.go

// 校验任务条件
package rtask

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	cfg "go_dreamfactory/sys/configure/structs"
	"go_dreamfactory/utils"

	"github.com/spf13/cast"
)

// n params (1-GreatEqual 2-equal 3-equal 4-equal 5-equal)
func (this *ModelRtaskRecord) verifyMultiEqual(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	if len(params) == 0 {
		err = fmt.Errorf("玩家参数数据缺失,用户参数:%v", params)
		return
	}
	var paramLen int
	if paramLen, err = lenParam(cfg, params...); err == nil {
		//参数比较,默认第一个参数soGreateEqual,其它soEqual
		switch paramLen {
		case 1:
			// ok, err = soGreatEqual(params[0], cfg.Data1)
			ok = true
			return
		case 2:
			// if ok, err = soGreatEqual(params[0], cfg.Data1); !ok {
			// 	return
			// }
			if ok, err = soEqual(params[1], cfg.Data2); !ok {
				return
			}
		case 3:
			// if ok, err = soGreatEqual(params[0], cfg.Data1); !ok {
			// 	return
			// }
			if ok, err = soEqual(params[1], cfg.Data2); !ok {
				return
			}
			if ok, err = soEqual(params[2], cfg.Data3); !ok {
				return
			}
		case 4:
			// if ok, err = soGreatEqual(params[0], cfg.Data1); !ok {
			// 	return
			// }
			if ok, err = soEqual(params[1], cfg.Data2); !ok {
				return
			}
			if ok, err = soEqual(params[2], cfg.Data3); !ok {
				return
			}
			if ok, err = soEqual(params[3], cfg.Data4); !ok {
				return
			}
		case 5:
			// if ok, err = soGreatEqual(params[0], cfg.Data1); !ok {
			// 	return
			// }
			if ok, err = soEqual(params[1], cfg.Data2); !ok {
				return
			}
			if ok, err = soEqual(params[2], cfg.Data3); !ok {
				return
			}
			if ok, err = soEqual(params[3], cfg.Data4); !ok {
				return
			}
			if ok, err = soEqual(params[4], cfg.Data5); !ok {
				return
			}
		}
	}

	return
}

// firstParam (first-Equal)
func (this *ModelRtaskRecord) verifyFirstEqualParam(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	if len(params) == 1 {
		ok, err = soEqual(params[0], cfg.Data1)
	}

	return
}

// firstParam (first-greatEqual)
func (this *ModelRtaskRecord) verifyFirstGreatEqualParam(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	if len(params) != 1 {
		err = fmt.Errorf("玩家参数数据缺失,用户参数:%v", params)
		return
	}
	ok = true
	return
}

// three params (first-greatEqual second-equal third-lessEqual)
func (this *ModelRtaskRecord) verifyThirdLessEqualParam(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	if len(params) != 3 {
		err = fmt.Errorf("玩家参数数据缺失,用户参数:%v", params)
		return
	}
	var paramLen int
	if paramLen, err = lenParam(cfg, params...); err == nil {
		//参数比较,默认第一个参数soGreateEqual,其它soEqual
		switch paramLen {
		case 1:
			ok = true
			return
		case 2:
			if ok, err = soEqual(params[1], cfg.Data2); !ok {
				return
			}
		case 3:
			if ok, err = soEqual(params[1], cfg.Data2); !ok {
				return
			}
			if ok, err = soLessEqual(params[2], cfg.Data3); !ok {
				return
			}
		}
	}
	return
}

// three params (first-greatEqual second-equal third-greatEqual)
func (this *ModelRtaskRecord) verifyThirdGreatEqualParam(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	if len(params) != 3 {
		err = fmt.Errorf("玩家参数数据缺失,用户参数:%v", params)
		return
	}
	var paramLen int
	if paramLen, err = lenParam(cfg, params...); err == nil {
		//参数比较,默认第一个参数soGreateEqual,其它soEqual
		switch paramLen {
		case 1:
			ok = true
			return
		case 2:
			if ok, err = soEqual(params[1], cfg.Data2); !ok {
				return
			}
		case 3:
			if ok, err = soEqual(params[1], cfg.Data2); !ok {
				return
			}
			if ok, err = soGreatEqual(params[2], cfg.Data3); !ok {
				return
			}
		}
	}
	return
}

// two params (first-Equal second-Equal)
func (this *ModelRtaskRecord) veriftyEqualParam(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	if len(params) != 2 {
		err = fmt.Errorf("玩家参数数据缺失,用户参数:%v", params)
		return
	}
	// var paramLen int
	if _, err = lenParam(cfg, params...); err == nil {
		if ok, err = soEqual(params[1], cfg.Data2); !ok {
			return
		}
		// }
	}
	return
}

// two params (first-Equal second-GreatEqual)
func (this *ModelRtaskRecord) veriftyGreatEqualParam(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	if len(params) != 2 {
		err = fmt.Errorf("玩家参数数据缺失,用户参数:%v", params)
		return
	}
	// var paramLen int
	if _, err = lenParam(cfg, params...); err == nil {
		if ok, err = soGreatEqual(params[1], cfg.Data2); !ok {
			return
		}
	}
	return
}

// 英雄指定
func (this *ModelRtask) verfiyRtype1(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, err error) {
	heroModule, err := this.service.GetModule(comm.ModuleHero)
	if err != nil {
		return false, err
	}

	if h, y := heroModule.(comm.IHero); y {
		for _, v := range h.GetHeroList(uid) {
			ok, err = soEqual(cast.ToString(cfg.Data1), v.HeroID)
			if ok {
				return
			}
		}
	}
	return
}

// 剧情
// Deprecated
func (this *ModelRtask) verifyRtype2(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, err error) {
	m, err := this.service.GetModule(comm.ModuleMline)
	if err != nil {
		return
	}

	if ml, y := m.(comm.IMline); y {
		qjId := ml.GetUserMlineData(uid, 1)
		return soEqual(qjId, cfg.Data1)
	}
	return
}

// 每日任务
// Deprecated
func (this *ModelRtask) verifyRtype3(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	m, err := this.service.GetModule(comm.ModuleTask)
	if err != nil {
		return
	}

	if ml, y := m.(comm.ITask); y {
		for _, task := range ml.GetTaskDayFinished(uid) {
			if task.TaskId >= cfg.Data1 {
				ok = true
				break
			}
		}
	}
	return
}

// 指定英雄等级
func (this *ModelRtask) verifyRtype4(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	m, err := this.service.GetModule(comm.ModuleHero)
	if err != nil {
		return
	}

	if ml, y := m.(comm.IHero); y {
		var hero *pb.DBHero
		for _, v := range ml.GetHeroList(uid) {
			if cast.ToString(cfg.Data1) == v.HeroID {
				hero = v
				break
			}
		}
		if hero != nil {
			if ok, err = soEqual(hero.HeroID, cast.ToString(cfg.Data1)); !ok {
				return
			}
			if ok, err = soGreatEqual(hero.Lv, cfg.Data2); !ok {
				return
			}
		}
	}
	return
}

// 指定英雄的指定装备数量
func (this *ModelRtask) verifyRtype5(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, err error) {
	m, err := this.service.GetModule(comm.ModuleHero)
	if err != nil {
		return
	}

	if ml, y := m.(comm.IHero); y {
		var (
			hero   *pb.DBHero
			heroId string
		)

		for _, v := range ml.GetHeroList(uid) {
			if cast.ToString(cfg.Data1) == v.HeroID {
				hero = v
				break
			}
		}

		var count int32
		if hero != nil {
			heroId = hero.HeroID
			for _, v := range hero.EquipID {
				if v != "" {
					count++
				}
			}
		}
		if ok, err = soEqual(heroId, cast.ToString(cfg.Data1)); !ok {
			return
		}
		return soGreatEqual(count, cfg.Data2)
	}
	return
}

// 指定英雄星级
func (this *ModelRtask) verifyRtype6(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, err error) {
	m, err := this.service.GetModule(comm.ModuleHero)
	if err != nil {
		return
	}

	if ml, y := m.(comm.IHero); y {
		var hero *pb.DBHero
		for _, v := range ml.GetHeroList(uid) {
			if cast.ToString(cfg.Data1) == v.HeroID {
				hero = v
				break
			}
		}

		if hero != nil {
			if ok, err = soEqual(hero.HeroID, cast.ToString(cfg.Data1)); !ok {
				return
			}
			return soGreatEqual(hero.Star, cfg.Data2)
		}
	}
	return
}

// 日常登录一次
func (this *ModelRtask) verfiyRtype7(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, err error) {
	userModule, err := this.service.GetModule(comm.ModuleUser)
	if err != nil {
		return
	}

	if um, y := userModule.(comm.IUser); y {
		if user := um.GetUser(uid); user != nil {
			return soEqual(utils.IsToday(user.Logintime), true)
		}
	}
	return
}

// 累计登陆xx天
func (this *ModelRtask) verfiyRtype8(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, err error) {
	userModule, err := this.service.GetModule(comm.ModuleUser)
	if err != nil {
		return
	}

	if um, y := userModule.(comm.IUser); y {
		ud, err := um.GetUserExpand(uid)
		if err != nil {
			return false, err
		}
		return soGreatEqual(ud.LoginAddCount, cfg.Data1)
	}
	return
}

// 连续登陆xx天  未埋点的处理方法
func (this *ModelRtask) verfiyRtype9(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	userModule, err := this.service.GetModule(comm.ModuleUser)
	if err != nil {
		return
	}

	if um, y := userModule.(comm.IUser); y {
		ud, err := um.GetUserExpand(uid)
		if err != nil {
			return false, 0, err
		}
		ok, err = soGreatEqual(ud.LoginContinueCount, cfg.Data1)
	}
	return
}

// 拥有xx个好友
func (this *ModelRtask) verfiyRtype10(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	m, err := this.service.GetModule(comm.ModuleFriend)
	if err != nil {
		return
	}

	if mi, y := m.(comm.IFriend); y {
		count := mi.GetFriendCount(uid)
		ok, err = soGreatEqual(count, cfg.Data1)
	}
	return
}

// 用户等级达到xx级
func (this *ModelRtask) verifyRtype20(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	userModule, err := this.service.GetModule(comm.ModuleUser)
	if err != nil {
		return
	}

	if um, y := userModule.(comm.IUser); y {
		if user := um.GetUser(uid); user != nil {
			ok, err = soGreatEqual(user.Lv, cfg.Data1)
			return
		}
	}
	return
}

// 日常任务活跃度达到xx
func (this *ModelRtask) verifyRtype63(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	userModule, err := this.service.GetModule(comm.ModuleUser)
	if err != nil {
		return
	}

	if um, y := userModule.(comm.IUser); y {
		de, err := um.GetUserExpand(uid)
		if err != nil {
			return false, 0, err
		}

		if de != nil {
			ok, err = soGreatEqual(de.Activeday, cfg.Data1)
		}
	}

	return
}

// 记录玩家在线时间并记入进度
func (this *ModelRtask) verifyRtype138(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	userModule, err := this.service.GetModule(comm.ModuleUser)
	if err != nil {
		return
	}

	if um, y := userModule.(comm.IUser); y {
		if user := um.GetUser(uid); user != nil {
			now := configure.Now().Unix()
			l := (now - user.Logintime) / 60
			ok, err = soGreatEqual(int32(l), cfg.Data1)
			return
		}
	}
	return
}

func (this *ModelRtask) verifyRtype43(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	equipment, ec := this.module.ModuleEquipment.QueryEquipments(uid)
	if ec == pb.ErrorCode_Success {
		for _, e := range equipment {
			if ok, _ = soGreatEqual(e.Lv, cfg.Data2); ok {
				count++
			}
		}
	}
	ok = true
	return
}

func (this *ModelRtask) verifyRtype111(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	m, err := this.service.GetModule(comm.ModuleHero)
	if err != nil {
		return
	}

	if ml, y := m.(comm.IHero); y {
		for _, hero := range ml.GetHeroList(uid) {
			if ok, err = soGreatEqual(hero.Lv, cfg.Data2); ok {
				count++
			}
		}
	}
	ok = true
	return
}

func (this *ModelRtask) verifyRtype123(uid string, cfg *cfg.GameRdtaskCondiData, params ...int32) (ok bool, count int32, err error) {
	m, err := this.service.GetModule(comm.ModuleHero)
	if err != nil {
		return
	}

	if ml, y := m.(comm.IHero); y {
		heroList := ml.GetHeroList(uid)
		for _, heroId := range ml.QueryHeroTelnetByCount(uid, int(cfg.Data2)) {
			for _, hero := range heroList {
				if heroId == hero.Id && hero.Star == cfg.Data3 {
					count++
				}
			}
		}
	}
	ok = true
	return
}