server/game/game_cluster/internal/mdb/models/player.go

package models

import (
	"context"
	"fmt"
	jsoniter "github.com/json-iterator/go"
	mhayaString "github.com/mhaya/extend/string"
	mhayaTime "github.com/mhaya/extend/time"
	"github.com/mhaya/game/game_cluster/internal/constant"
	"github.com/mhaya/game/game_cluster/internal/data"
	"github.com/mhaya/game/game_cluster/internal/mdb"
	"github.com/mhaya/game/game_cluster/internal/param"
	"github.com/mhaya/game/game_cluster/internal/token"
	"time"

	mhayaLogger "github.com/mhaya/logger"
	"math/rand"
	"strings"
)

type Player struct {
	UserName          string                    `json:"userName" bson:"userName"`
	OpenId            string                    `json:"openId" bson:"openId"`
	UserNameMaybe     string                    `json:"userNameMaybe" bson:"userNameMaybe"`
	NickName          string                    `json:"nickName" bson:"nickName"`
	Pid               string                    `json:"pid" bson:"pid"`
	XID               string                    `json:"xID" bson:"xID"`
	TonWall           string                    `json:"tonWall" bson:"tonWall"`
	Email             string                    `json:"email" bson:"email"`
	Mobile            string                    `json:"mobile" bson:"mobile"`
	Avatar            string                    `json:"avatar" bson:"avatar"`
	IsRobot           int                       `json:"isRobot" bson:"isRobot"`
	IsLeader          int                       `json:"isLeader" bson:"isLeader"`
	IsVip             int                       `json:"isVip" bson:"isVip"`
	IsFirstBindingXID int                       `json:"isFirstBindingXID" bson:"isFirstBindingXID"`
	Level             int                       `json:"level" bson:"level"`
	Exp               int                       `json:"exp" bson:"exp"`
	Gender            int                       `json:"gender" bson:"gender"`
	Birthday          string                    `json:"birthday" bson:"birthday"`
	Successions       int                       `json:"successions" bson:"successions"`
	MaxSuccessions    int                       `json:"maxSuccessions" bson:"maxSuccessions"`
	PrevTime          int64                     `json:"prevTime" bson:"prevTime"`
	LoginTime         int64                     `json:"loginTime" bson:"loginTime"`
	LoginIP           string                    `json:"loginIP" bson:"loginIP"`
	LoginFailure      int                       `json:"loginFailure" bson:"loginFailure"`
	JoinIP            string                    `json:"joinIP" bson:"joinIP"`
	Rank              int                       `json:"rank" bson:"rank"`
	JoinTime          int64                     `json:"joinTime" bson:"joinTime"`
	CreateTime        int64                     `json:"createTime" bson:"createTime"`
	UpdateTime        int64                     `json:"updateTime" bson:"updateTime"`
	DailyRefreshTime  int64                     `json:"dailyRefreshTime" bson:"dailyRefreshTime"`
	WeeklyRefreshTime int64                     `json:"weeklyRefreshTime" bson:"weeklyRefreshTime"`
	RollDay           int64                     `json:"rollDay" bson:"rollDay"`
	Status            int                       `json:"status" bson:"status"`
	Roll              *Roll                     `json:"roll" bson:"roll"`
	Guide             int                       `json:"guide" bson:"guide"`
	Share             *Share                    `json:"share" bson:"share"`
	FirstReward       int                       `json:"firstReward" bson:"firstReward"`
	Index             int                       `json:"-" bson:"index"`
	Item              ItemBasePack              `json:"item" bson:"item"`
	SinIn             SignIn                    `json:"sinIn" bson:"sinIn"`
	DailyTask         DailyTask                 `json:"dailyTask" bson:"dailyTask"`
	AchieveTask       AchieveTask               `json:"achieveTask" bson:"achieveTask"`
	RankReward        RankReward                `json:"rankReward" bson:"rankReward"`
	Invite            Invite                    `json:"invite" bson:"invite"`
	InviteReward      *InviteReward             `json:"inviteReward" bson:"inviteReward"`
	PlayerReward      map[int]*PlayerRewardBase `json:"-" bson:"-"`
}

func NewPlayer(token *token.Token) *Player {
	return &Player{
		UserName:       token.PlayerID,
		OpenId:         token.OpenID,
		NickName:       token.Nickname,
		IsRobot:        0,
		Successions:    1,
		MaxSuccessions: 1,
		LoginTime:      mhayaTime.Now().Unix(),
		CreateTime:     mhayaTime.Now().Unix(),
		UpdateTime:     mhayaTime.Now().Unix(),
		RollDay:        mhayaTime.Now().Unix(),
		Exp:            0,
		Status:         1,
		Rank:           0,
		Item:           NewItem(),
		Guide:          1,
		Level:          1,
		Index:          1,
		FirstReward:    1,
		Roll:           &Roll{RollNums: 0, RollDays: 0},
		DailyTask:      NewDailyTask(),
		Share:          &Share{IsDrawShare: 0},
		SinIn:          NewSignIn(),
		AchieveTask:    NewAchieveTask(),
		RankReward:     NewRankReward(),
		Invite:         NewInvite(),
	}
}

func NewBotPlayer(token *token.Token) *Player {
	return &Player{
		UserName:       token.PlayerID,
		OpenId:         token.OpenID,
		NickName:       token.Nickname,
		IsRobot:        1,
		Successions:    1,
		MaxSuccessions: 1,
		LoginTime:      mhayaTime.Now().Unix(),
		CreateTime:     mhayaTime.Now().Unix(),
		UpdateTime:     mhayaTime.Now().Unix(),
		RollDay:        mhayaTime.Now().Unix(),
		Exp:            0,
		Status:         1,
		Rank:           0,
		Item:           NewItem(),
		Guide:          1,
		Level:          1,
		Index:          1,
		FirstReward:    1,
		Roll:           &Roll{RollNums: 0, RollDays: 0},
		DailyTask:      NewDailyTask(),
		Share:          &Share{IsDrawShare: 0},
		SinIn:          NewSignIn(),
		AchieveTask:    NewAchieveTask(),
		RankReward:     NewRankReward(),
		Invite:         NewInvite(),
	}
}
func (p *Player) Init() {
	if p.InviteReward == nil {
		p.InviteReward = &InviteReward{IsClaim: 0}
	}
}

// InitDaily 每日刷新
func (p *Player) InitDaily() {
	p.DailyRefreshTime = mhayaTime.Now().Add(-24 * time.Hour).Unix()
	if !mhayaTime.CreateFromTimestamp(p.DailyRefreshTime).IsToday() {
		//刷新每日任务
		p.DailyTask.RefreshDailyTask()
		//刷新抽奖每日分享
		p.Share.RefreshShare()
		//刷新是否有排行榜奖励
		p.RankReward.InitRank(p.UserName, 1)
		//更新时间到当天
		p.DailyRefreshTime = mhayaTime.Now().Unix()
	}
}

func (p *Player) InitWeekly() {
	if !mhayaTime.CreateFromTimestamp(p.WeeklyRefreshTime).IsThisWeek() {

		p.SinIn.RefreshSignIn()
		//刷新是否有排行榜奖励
		p.RankReward.InitRank(p.UserName, 2)

		p.WeeklyRefreshTime = mhayaTime.Now().Unix()
	}
}

func (p *Player) InitAchieveTask() {
	p.AchieveTask.RefreshAchieveTask()
}

func (p *Player) LevelUp() bool {
	ret, ok := data.LevelConfig.Get(p.Level + 1)
	if !ok {
		return false
	}
	curLevel := p.Level
	if p.Item[ItemRoll].CurNum >= ret.DiceNum && p.Item[ItemInvite].CurNum >= ret.Invite {
		p.Level += 1
		if p.Level > curLevel {
			p.Item[ItemRoll].AddMaxNum(ret.DiceLimit)
			p.Item[ItemRoll].CurNum = 0
			p.Item[ItemInvite].CurNum = 0

			//升级邀请奖励
			p.SetPassiveInviteReward()

			p.SetPlayerRewardLog(SourceLevelUp, p.Level, []data.ItemReward{{ItemID: ItemAllRoll, ItemBaseType: 2, Amount: ret.DiceLimit}}, []data.ItemReward{}, p.Level)
			return true
		}
	}

	return false
}

func (p *Player) RefreshRoll() bool {
	ret, ok := data.DiscreteRuleConfig.Get(RefreshRoll)
	if !ok {
		return false
	}
	arr := strings.Split(ret.Condition, ",")
	if len(arr) != 2 {
		return false
	}
	h, _ := mhayaString.ToInt64(arr[0])
	m, _ := mhayaString.ToInt64(arr[1])
	s := mhayaTime.CreateFromTimestamp(p.RollDay).DiffInSeconds(mhayaTime.Now())
	if s >= h {
		p.RollDay = mhayaTime.Now().Unix()
		num := p.Item[ItemRoll].AddAll()
		if num > 0 {
			p.SetPlayerRewardLog(SourceRefreshRoll, 1, []data.ItemReward{{ItemID: ItemRoll, ItemBaseType: 1, Amount: num}}, []data.ItemReward{}, 0)
		}
		mhayaLogger.Infof("RefreshRoll by condition 1 rollDay:%d,num:%v", s, num)
		return true
	} else if s >= m {
		p.RollDay = mhayaTime.Now().Unix()
		num := p.Item[ItemRoll].AddSame()
		if num > 0 {
			p.SetPlayerRewardLog(SourceRefreshRoll, 2, []data.ItemReward{{ItemID: ItemRoll, ItemBaseType: 1, Amount: num}}, []data.ItemReward{}, 0)
		}
		mhayaLogger.Infof("RefreshRoll by condition 2 rollDay:%d,num:%v", s, num)
		return true
	}
	return false
}

// FinishAchieveTaskByType1 完成成就类型1
func (p *Player) FinishAchieveTaskByType1(id int) bool {
	if a, ok := p.AchieveTask[id]; ok {
		if a.Num == 0 {
			p.AchieveTask[id].Num = 1
			p.AchieveTask[id].Status = 1
			return true
		}
	}
	return false
}

// FinishAchieveTaskByType2 完成成就类型1
func (p *Player) FinishAchieveTaskByType2() bool {
	var cur int
	for _, v := range p.AchieveTask {
		if v.Type == 2 {
			ret, ok := data.AchieveTaskConfig.Get(v.ID)
			if !ok {
				continue
			}
			if v.Num < ret.Condition && v.Num >= cur {
				p.AchieveTask[v.ID].Num += 1
				p.AchieveTask[v.ID].Status = 1
				p.AchieveTask[v.ID].RewardNum += 1
				return true
			}
			cur = ret.Condition
		}
	}
	return false
}

func (p *Player) FinishDailyTask(tp, num int) bool {
	var f bool
	for i := 0; i < num; i++ {
		for _, v := range p.DailyTask {
			if v.Type == tp && v.Status == 0 {
				p.DailyTask[v.ID].Num += 1
				if p.DailyTask[v.ID].Num == v.Condition {
					p.DailyTask[v.ID].Status = 1
					f = true
					continue
				}
			}
		}
	}

	return f
}

func (p *Player) RollOnce(num int) *param.RollOnce {
	var roll param.RollOnce
	levelConfig, ok := data.LevelConfig.Get(p.Level)
	if !ok {
		return nil
	}

	if levelConfig == nil {
		return nil
	}
	r1 := rand.Int31n(5) + 1
	r2 := rand.Int31n(5) + 1
	r3 := rand.Int31n(5) + 1

	//rule 4
	if (r1 == 1 && r2 == 1 && r3 == 1) || (r1 == 6 && r2 == 6 && r3 == 6) {
		roll.Score = levelConfig.Ratio * levelConfig.Rule4
		roll.RollType = constant.RollSpecialTripleBet
	} else if r1 == r2 && r2 == r3 {
		roll.Score = levelConfig.Ratio * levelConfig.Rule3
		roll.RollType = constant.RollTripleBet
	} else if r1 == r2 || r1 == r3 || r2 == r3 {
		roll.Score = levelConfig.Ratio * levelConfig.Rule2
		roll.RollType = constant.RollDoubleBet
	} else {
		roll.Score = levelConfig.Ratio * levelConfig.Rule1
		if r1+r2+r3 > 9 {
			roll.RollType = constant.RollBigBet
		} else {
			roll.RollType = constant.RollSmallBet
		}
	}

	roll.Rand = make(map[int]int32)
	roll.Rand[1] = r1
	roll.Rand[2] = r2
	roll.Rand[3] = r3

	p.Item[ItemScore].Add(roll.Score * num)
	p.Item[ItemRoll].sub(1 * num)

	p.SetPlayerRewardLog(SourceRoll, 0, []data.ItemReward{{ItemID: ItemScore, ItemBaseType: 1, Amount: roll.Score * num}}, []data.ItemReward{{ItemID: ItemRoll, ItemBaseType: 1, Amount: 1 * num}}, roll)

	p.Roll.RollNums += 1 * num
	roll.IsDailyTask = p.FinishDailyTask(1, num)
	roll.IsLevelUp = p.LevelUp()

	return &roll
}

// Draw 最多尝试重复执行50次
func (p *Player) Draw() *param.Draw {
	for i := 0; i < 50; i++ {
		draw, ok := p.DrawOnce()
		if ok {
			return draw
		}
	}
	return nil
}

func (p *Player) DrawOnce() (*param.Draw, bool) {
	var ret map[int]*data.DrawConfigRow
	var draw param.Draw
	if p.Item[ItemDrawsNumber].Num <= 10 {
		ret = data.DrawConfig.GetByType(1)
	} else {
		ret = data.DrawConfig.GetByType(2)
	}
	weight := int(rand.Int31n(9999))
	var cur int
	var curID int
	var drawId int
	for _, v := range ret {
		if v.Weight == 0 {
			continue
		}
		if weight >= cur && weight < cur+v.Weight {
			curID = v.ID
			drawId = v.Order
			break
		}
		cur += v.Weight
	}
	if d, ok := ret[curID]; ok {
		if d.HourTotalCondition > 0 {
			i, err := GetDrawHour(curID)
			if err != nil {
				return nil, false
			}
			if int(i) > d.HourTotalCondition {
				return nil, false
			}
		}

		if d.DailyTotalCondition > 0 {
			i, err := GetDrawDailyKey(curID)
			if err != nil {
				return nil, false
			}
			if int(i) > d.DailyTotalCondition {
				return nil, false
			}
		}

		if d.WeeklyTotalCondition > 0 {
			i, err := GetDrawWeeklyKey(curID)
			if err != nil {
				return nil, false
			}
			if int(i) > d.WeeklyTotalCondition {
				return nil, false
			}
		}
		p.Item.AddItem(d.Reward)
		p.Item[ItemDrawsNumber].sub(1)
		draw.Reward = d.Reward
		draw.ID = drawId
		draw.CurID = curID
		if len(p.Roll.Draw) == 0 {
			p.Roll.Draw = make(map[int]int)
		}
		if len(p.Roll.DrawRatio) == 0 {
			p.Roll.DrawRatio = make(map[int]float64)
		}

		p.Roll.Draw[curID] += 1
		p.Roll.DrawTotal += 1

		p.Roll.DrawRatio[curID] = float64(p.Roll.Draw[curID]) / float64(p.Roll.DrawTotal)

		p.SetPlayerRewardLog(SourceDraw, 0, draw.Reward, []data.ItemReward{{1, ItemDrawsNumber, 1}}, draw)
	} else {
		return nil, false
	}
	return &draw, true
}

func GetDrawHour(id int) (int64, error) {
	s := mhayaTime.CreateFromTime(mhayaTime.Now().Hour(), 0, 0).ToDateTimeFormat()
	key := fmt.Sprintf("%v:%v:%v", constant.DrawHourKey, id, s)
	return mdb.RDB.IncrBy(context.Background(), key, 1).Result()
}

func GetDrawDailyKey(id int) (int64, error) {
	key := fmt.Sprintf("%v:%v:%v", constant.DrawDailyKey, id, mhayaTime.Now().Format(mhayaTime.DateFormat))
	return mdb.RDB.IncrBy(context.Background(), key, 1).Result()
}

func GetDrawWeeklyKey(id int) (int64, error) {
	key := fmt.Sprintf("%v:%v:%v", constant.DrawWeeklyKey, id, mhayaTime.Now().Week())
	return mdb.RDB.IncrBy(context.Background(), key, 1).Result()
}

func (p *Player) SignIn() *param.ChangeData {
	var sign param.ChangeData
	p.SinIn.SignDailyTime = mhayaTime.Now().Unix()
	p.SinIn.Sign[p.SinIn.Num].IsSign = 1
	p.SinIn.Sign[p.SinIn.Num].SignTime = mhayaTime.Now().Unix()
	var addItem AddItem
	at := addItem.Add(p.SinIn.Sign[p.SinIn.Num].Reward)
	sign.AddItem = at
	p.Item.AddItem(p.SinIn.Sign[p.SinIn.Num].Reward)
	p.SinIn.Num += 1

	p.SetPlayerRewardLog(SourceSignIn, p.SinIn.Num, p.SinIn.Sign[p.SinIn.Num].Reward, []data.ItemReward{}, nil)

	sign.IsLevelUp = p.LevelUp()
	return &sign
}

func (p *Player) SetPlayerRewardLog(tp, tid int, addReward, subReward []data.ItemReward, desc interface{}) {
	p.Index += 1
	if len(p.PlayerReward) == 0 {
		p.PlayerReward = make(map[int]*PlayerRewardBase)
	}
	p.PlayerReward[p.Index] = &PlayerRewardBase{
		UserName:   p.UserName,
		AddReward:  addReward,
		SubReward:  subReward,
		Desc:       desc,
		Source:     tp,
		SourceId:   tid,
		CreateTime: mhayaTime.Now().Unix(),
	}

}

func (p *Player) SetPassiveInviteReward() {

	ret2, ok := data.DiscreteRuleConfig.Get(InvitePlayer)
	c, tok := mhayaString.ToInt(ret2.Condition)
	if !ok || !tok || c != p.Level {
		return
	}

	ret3, ok := data.DiscreteRuleConfig.Get(InviteVipPlayer)
	c, tok = mhayaString.ToInt(ret3.Condition)
	if !ok || !tok || c != p.Level {
		return
	}
	//被动邀请
	key := fmt.Sprintf("%v:1:%v", constant.InviteKey, p.UserName)
	pUid := mdb.RDB.Get(context.Background(), key).Val()

	pbase, err := mdb.RDB.Get(context.Background(), GetPlayBaseKey(pUid)).Bytes()
	if err != nil {
		return
	}
	mdb.RDB.Del(context.Background(), key)
	var base param.PlayerBase
	err = jsoniter.Unmarshal(pbase, &base)
	if err != nil {
		return
	}

	var addItem []data.ItemReward
	if p.IsVip == 0 {
		//主动邀请记录
		key = fmt.Sprintf("%v:%v:%v", constant.InviteKey, InvitePlayer, pUid)
		mdb.RDB.IncrBy(context.Background(), key, 1)

		addItem = append(addItem, ret2.Reward...)
	} else {

		key = fmt.Sprintf("%v:%v:%v", constant.InviteKey, InviteVipPlayer, pUid)
		mdb.RDB.IncrBy(context.Background(), key, 1)

		addItem = append(addItem, ret3.Reward...)
	}

	if base.IsLeader == 1 {
		ret, ok := data.DiscreteRuleConfig.Get(InvitePlayerByLeader)
		if !ok {
			return
		}
		addItem = append(addItem, ret.Reward...)
	}
	if p.InviteReward.IsClaim == 2 {
		p.InviteReward.Reward = []data.ItemReward{}
		p.InviteReward.IsClaim = 0
		p.InviteReward.RewardTime = 0
	}
	p.InviteReward.Reward = append(p.InviteReward.Reward, addItem...)

}

func (p *Player) SetInviteReward() {
	ret, ok := data.DiscreteRuleConfig.Get(InvitePlayerByLeader)
	if !ok {
		return
	}
	ret2, ok := data.DiscreteRuleConfig.Get(InvitePlayer)
	c, tok := mhayaString.ToInt(ret2.Condition)
	if !ok || !tok || c != p.Level {
		return
	}

	ret3, ok := data.DiscreteRuleConfig.Get(InviteVipPlayer)
	c, tok = mhayaString.ToInt(ret3.Condition)
	if !ok || !tok || c != p.Level {
		return
	}
	var addItem []data.ItemReward

	key1 := fmt.Sprintf("%v:%v:%v", constant.InviteKey, InvitePlayer, p.UserName)
	key2 := fmt.Sprintf("%v:%v:%v", constant.InviteKey, InviteVipPlayer, p.UserName)

	freeNum, _ := mdb.RDB.Get(context.Background(), key1).Int()

	VipNum, _ := mdb.RDB.Get(context.Background(), key2).Int()

	for i := 0; i < freeNum; i++ {
		addItem = append(addItem, ret2.Reward...)
		p.SetPlayerRewardLog(SourceInvite, InvitePlayer, []data.ItemReward{}, []data.ItemReward{}, 2)
		if p.IsLeader == 1 {
			addItem = append(addItem, ret.Reward...)
			p.SetPlayerRewardLog(SourceInvite, InvitePlayerByLeader, []data.ItemReward{}, []data.ItemReward{}, 2)
		}
		mdb.RDB.DecrBy(context.Background(), key1, 1)
	}

	for i := 0; i < VipNum; i++ {
		addItem = append(addItem, ret3.Reward...)
		p.SetPlayerRewardLog(SourceInvite, InviteVipPlayer, []data.ItemReward{}, []data.ItemReward{}, 2)
		if p.IsLeader == 1 {
			addItem = append(addItem, ret.Reward...)
			p.SetPlayerRewardLog(SourceInvite, InvitePlayerByLeader, []data.ItemReward{}, []data.ItemReward{}, 2)
		}
		mdb.RDB.DecrBy(context.Background(), key2, 1)
	}

	if (freeNum + VipNum) > 0 {
		SetRank(constant.RankSourceInvite, p.IsRobot, p.UserName, freeNum+VipNum)
	}

	if p.InviteReward.IsClaim == 2 {
		p.InviteReward.Reward = []data.ItemReward{}
		p.InviteReward.IsClaim = 0
		p.InviteReward.RewardTime = 0
	}
	p.InviteReward.Reward = append(p.InviteReward.Reward, addItem...)
}

func (p *Player) SetInvite(uid string) bool {
	key := fmt.Sprintf("%v:1:%v", constant.InviteKey, p.UserName)
	ret, ok := data.DiscreteRuleConfig.Get(InviteMaxExpireTime)
	if !ok {
		return false
	}
	t, _ := mhayaString.ToInt64(ret.Condition)
	err := mdb.RDB.Set(context.Background(), key, uid, time.Duration(t)*24*time.Hour).Err()
	if err != nil {
		return false
	}
	return true
}

func (p *Player) ClaimRankReward(id int) param.ChangeData {
	var resp param.ChangeData
	if rank, ok := p.RankReward[id]; ok {
		if rank.IsClaim == 0 && len(rank.Reward) > 0 {
			var addItem AddItem
			resp.AddItem = addItem.Add(rank.Reward)
			p.Item.AddItem(rank.Reward)
			p.RankReward[id].IsClaim = 1

			p.RankReward[id].ClaimTime = mhayaTime.Now().Unix()
			p.SetPlayerRewardLog(SourceRank, id, rank.Reward, []data.ItemReward{}, nil)
		}
	}
	p.LevelUp()

	return resp
}

func (p *Player) ClaimInviteReward(id int) param.ChangeData {
	var resp param.ChangeData
	if p.InviteReward.IsClaim == 0 {
		var addItem AddItem
		resp.AddItem = addItem.Add(p.InviteReward.Reward)
		p.Item.AddItem(p.InviteReward.Reward)
		p.InviteReward.IsClaim = 1
		p.InviteReward.RewardTime = mhayaTime.Now().Unix()

		p.SetPlayerRewardLog(SourceInvite, id, p.InviteReward.Reward, []data.ItemReward{}, nil)
	}
	p.LevelUp()

	return resp
}

func (p *Player) ClaimAchieveTaskReward(id int) param.ChangeData {
	var resp param.ChangeData
	if ach, ok := p.AchieveTask[id]; ok {
		if ach.Status == 1 && ach.RewardNum > 0 {
			var addItem AddItem
			resp.AddItem = addItem.Add(ach.Reward)
			p.Item.AddItem(ach.Reward)
			ach.RewardNum -= 1
			p.SetPlayerRewardLog(SourceAchieveTask, id, ach.Reward, []data.ItemReward{}, nil)
		}
		if ach.RewardNum == 0 {
			p.AchieveTask[id].Status = 2
		}
	}
	p.LevelUp()

	return resp
}

func (p *Player) ClaimDailyTaskReward(id int) param.ChangeData {
	var resp param.ChangeData
	if task, ok := p.DailyTask[id]; ok {
		if task.Status == 1 {
			var addItem AddItem
			resp.AddItem = addItem.Add(task.Reward)
			p.Item.AddItem(task.Reward)
			task.Status = 2
			p.SetPlayerRewardLog(SourceDailyTask, id, task.Reward, []data.ItemReward{}, nil)
		}
	}
	p.LevelUp()

	return resp
}