task

server/wheelserver/api/v1/activity/activity.go

@@ -127,9 +127,8 @@ func (this *ActivityApi) RollDice(c *gin.Context) {
 			}
 
 			awardgridids := mt.Table.MapGrid.GetAwardGridIdList()
-			if len(awardgridids) > len(userAwardgrids)+1 {
 			user.AddAwardGrid(user.CurrGrid)
-			} else {
+			if len(awardgridids) >= len(userAwardgrids) {
 				fullgrid = true
 			}
 		}
@@ -137,7 +136,7 @@ func (this *ActivityApi) RollDice(c *gin.Context) {
 
 	rspObj.GetOrCreateAward().AddItem(constant.VIRTUAL_ITEM_SCORE, score)
 
-	if this.handleAwards(user, rspObj.GetOrCreateAward()) {
+	if service.Award.HandleAwards(user, rspObj.GetOrCreateAward()) {
 		q5.AppendSlice(&rspObj.BaseVo.GetOrCreateSideEffect().Effects, "bag")
 	}
 
@@ -194,48 +193,10 @@ func (this *ActivityApi) Claim(c *gin.Context) {
 		rspObj.GetOrCreateAward().AddItem(item.ItemId, item.ItemNum)
 	}
 
-	if this.handleAwards(user, rspObj.GetOrCreateAward()) {
+	if service.Award.HandleAwards(user, rspObj.GetOrCreateAward()) {
 		q5.AppendSlice(&rspObj.GetOrCreateSideEffect().Effects, "bag")
 	}
 	rspObj.GetOrCreateSideEffect().GetOrCreateUser().FromModel(user)
 
 	c.JSON(200, rspObj)
 }
-
-func (aa *ActivityApi) handleAwards(user *model.User, totalaward *vo.Award) bool {
-	bageffect := false
-	for _, awarditem := range totalaward.Items {
-		itemcfg := mt.Table.Item.GetById(int64(awarditem.ItemId))
-		switch itemcfg.GetItemType() {
-		case constant.ITEM_TYPE_SCORE:
-			user.AddScore(awarditem.ItemNum)
-		case constant.ITEM_TYPE_DICE:
-			user.AddDice(awarditem.ItemNum)
-		case constant.ITEM_TYPE_SPEC_DICE:
-			user.AddSpecDice(awarditem.ItemNum)
-		case constant.ITEM_TYPE_CHIP:
-			nowTime := int32(f5.GetApp().GetRealSeconds())
-			for i := int32(0); i < awarditem.ItemNum; i++ {
-				chip := new(model.Chip)
-				chip.AccountId = user.AccountId
-				chip.ItemId = awarditem.ItemId
-				chip.ItemNum = 1
-				chip.ExpireTime = nowTime + itemcfg.GetTime()*60
-				chip.CreateTime = nowTime
-				chip.ModifyTime = nowTime
-				if chip.Create() != nil {
-					f5.GetSysLog().Error("internal error, mapgrid chip award fail:%s, %d, %d", user.AccountId, user.CurrGrid, awarditem.ItemId)
-				}
-			}
-		case constant.ITEM_TYPE_SCORE_DOUBLE_CARD:
-			fallthrough
-		case constant.ITEM_TYPE_SCORE_SMALL_GIFT_PACK:
-			fallthrough
-		case constant.ITEM_TYPE_SCORE_BIG_GIFT_PACK:
-			service.Award.AddItem(user.AccountId, awarditem.ItemId, awarditem.ItemNum, nil)
-			bageffect = true
-		}
-	}
-
-	return bageffect
-}

server/wheelserver/api/v1/mission/mission.go

@@ -8,6 +8,7 @@ import (
 	"main/mt"
 	"main/vo"
 	"q5"
+	"wheelserver/service"
 
 	"github.com/gin-gonic/gin"
 )
@@ -24,39 +25,8 @@ func (this *MissionApi) List(c *gin.Context) {
 		vo.BaseVo
 		Data []*vo.Mission `json:"data"`
 	}{}
-	task := new(model.Task)
-	err, found := task.Find(s.GetAccountId())
-	if err != nil {
-		f5.RspErr(c, 500, "server internal error")
-		return
-	}
 
-	createTasks := true
+	rspObj.ErrCode, rspObj.ErrMsg = service.Task.List(s.GetAccountId(), &rspObj.Data)
-	if found {
-		tasks := task.GetTaskItems()
-		if tasks != nil {
-			createTasks = false
-
-		}
-	}
-
-	if createTasks {
-		tasks := []*model.TaskItem{}
-		mt.Table.Task.Traverse(func(taskMeta *mt.Task) bool {
-			taskitem := new(model.TaskItem)
-			taskitem.MissionId = taskMeta.GetId()
-			taskitem.Current = 0
-			taskitem.Target = taskMeta.GetParam1()
-			taskitem.Award = 0
-			taskitem.Time = int32(f5.GetApp().GetRealSeconds())
-			tasks = append(tasks, taskitem)
-			
-			missionVo := new(vo.Mission)
-			missionVo.FromModel(taskitem)
-			q5.AppendSlice(&rspObj.Data, missionVo)
-			return true
-		})
-	}
 	c.JSON(200, rspObj)
 }
 
@@ -79,6 +49,45 @@ func (this *MissionApi) UpdateTask(c *gin.Context) {
 		Data []*vo.Mission `json:"data"`
 	}{}
 
+	task := new(model.Task)
+	err, found := task.Find(s.GetAccountId())
+	if err != nil || !found {
+		f5.RspErr(c, 500, "server internal error")
+		return
+	}
+
+	tasks := task.GetTaskItems()
+	if tasks == nil {
+		f5.RspErr(c, 401, "bad request")
+		return
+	}
+
+	taskitem, ok := tasks[reqJson.MissionId]
+	if !ok {
+		f5.RspErr(c, 401, "bad request")
+		return
+	}
+
+	taskMeta := mt.Table.Task.GetById(int64(taskitem.MissionId))
+	if taskMeta == nil {
+		f5.RspErr(c, 500, "server internal error")
+		return
+	}
+
+	if taskMeta.GetConditon() != constant.TASK_COND_FRONT ||
+		taskitem.Target <= taskitem.Current {
+		f5.RspErr(c, 401, "bad request")
+		return
+	}
+
+	taskitem.Target++
+	task.UpdateTasks(tasks)
+
+	for _, taskitem := range tasks {
+		missionVo := new(vo.Mission)
+		missionVo.FromModel(taskitem)
+		q5.AppendSlice(&rspObj.Data, missionVo)
+	}
 
 	c.JSON(200, rspObj)
 }
@@ -102,6 +111,54 @@ func (this *MissionApi) ClaimTaskAward(c *gin.Context) {
 		Data []*vo.Mission `json:"data"`
 	}{}
 
+	task := new(model.Task)
+	err, found := task.Find(s.GetAccountId())
+	if err != nil || !found {
+		f5.RspErr(c, 500, "server internal error")
+		return
+	}
+
+	tasks := task.GetTaskItems()
+	if tasks == nil {
+		f5.RspErr(c, 401, "bad request")
+		return
+	}
+
+	taskitem, ok := tasks[reqJson.MissionId]
+	if !ok || taskitem.Current != taskitem.Target {
+		f5.RspErr(c, 401, "bad request")
+		return
+	}
+
+	taskMeta := mt.Table.Task.GetById(int64(taskitem.MissionId))
+	if taskMeta == nil {
+		f5.RspErr(c, 500, "server internal error")
+		return
+	}
+
+	user := new(model.User)
+	nowTime := f5.GetApp().GetRealSeconds()
+	if err, found := user.Find(s.GetAccountId(), nowTime); err != nil {
+		f5.RspErr(c, 500, "server internal error1")
+		return
+	} else if !found {
+		f5.RspErr(c, 500, "server internal error2")
+		return
+	}
+
+	taskitem.Award = 1
+	task.UpdateTasks(tasks)
+
+	for _, taskitem := range tasks {
+		missionVo := new(vo.Mission)
+		missionVo.FromModel(taskitem)
+		q5.AppendSlice(&rspObj.Data, missionVo)
+	}
+
+	if taskMeta.GetRewardType() == constant.TASK_AWARD_SCORE {
+		user.AddScore(taskMeta.GetReward())
+
+	}
 
 	c.JSON(200, rspObj)
 }

server/wheelserver/constant/constant.go

@@ -54,9 +54,19 @@ const (
 	PRESENT_DICE_LOOP = 1800
 )
 
+const (
+	TASK_TYPE_ONCE = 1
+	TASK_TYPE_DAILY = 2
+	TASK_TYPE_RANGE = 3
+)
+
 const (
 	TASK_COND_FRONT = 1
 	TASK_COND_BACK_GAIN = 2
 	TASK_COND_BACK_USE = 3
 	TASK_COND_BACK_BUY = 4
 )
+
+const (
+	TASK_AWARD_SCORE = 1
+)

server/wheelserver/model/task.go

@@ -15,7 +15,7 @@ type TaskItem struct {
 	Current   int32 `json:"current"`
 	Target    int32 `json:"target"`
 	Award     int32 `json:"award"`
-	Time      int32 `json:"time"`
+	Time      int64 `json:"time"`
 }
 
 type Task struct {
@@ -55,7 +55,7 @@ func (this *Task) Create() error {
 	return nil
 }
 
-func (this *Task) UpdateTask(tasks []*TaskItem) error {
+func (t *Task) UpdateTasks(tasks map[int32]*TaskItem) error {
 	if tasks == nil || len(tasks) < 1 {
 		return errors.New("")
 	}
@@ -74,18 +74,18 @@ func (this *Task) UpdateTask(tasks []*TaskItem) error {
 		sb.WriteByte('|')
 	}
 
-	this.Data = sb.String()
+	t.Data = sb.String()
-	this.ModifyTime = int32(f5.GetApp().GetRealSeconds())
+	t.ModifyTime = int32(f5.GetApp().GetRealSeconds())
-	if err := this.UpdateFields([]string{"data", "modifytime"}); err != nil {
+	if err := t.UpdateFields([]string{"data", "modifytime"}); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-func (this *Task) GetTaskItems() []*TaskItem {
+func (this *Task) GetTaskItems() map[int32]*TaskItem {
 	if this.Data != "" {
-		Tasks := []*TaskItem{}
+		Tasks := map[int32]*TaskItem{}
 		taskitems := strings.Split(this.Data, "|")
 		for _, itemstr := range taskitems {
 			strs := strings.Split(itemstr, ",")
@@ -97,8 +97,8 @@ func (this *Task) GetTaskItems() []*TaskItem {
 			taskitem.Current = q5.SafeToInt32(strs[1])
 			taskitem.Target = q5.SafeToInt32(strs[2])
 			taskitem.Award = q5.SafeToInt32(strs[3])
-			taskitem.Time = q5.SafeToInt32(strs[4])
+			taskitem.Time = q5.SafeToInt64(strs[4])
-			Tasks = append(Tasks, taskitem)
+			Tasks[taskitem.MissionId] = taskitem
 		}
 
 		return Tasks

server/wheelserver/service/award.go

@@ -52,3 +52,41 @@ func (this *award) AddItem(accountId string, itemId int32, itemNum int32, baseVo
 		}
 	}
 }
+
+func (aa *award) HandleAwards(user *model.User, totalaward *vo.Award) bool {
+	bageffect := false
+	for _, awarditem := range totalaward.Items {
+		itemcfg := mt.Table.Item.GetById(int64(awarditem.ItemId))
+		switch itemcfg.GetItemType() {
+		case constant.ITEM_TYPE_SCORE:
+			user.AddScore(awarditem.ItemNum)
+		case constant.ITEM_TYPE_DICE:
+			user.AddDice(awarditem.ItemNum)
+		case constant.ITEM_TYPE_SPEC_DICE:
+			user.AddSpecDice(awarditem.ItemNum)
+		case constant.ITEM_TYPE_CHIP:
+			nowTime := int32(f5.GetApp().GetRealSeconds())
+			for i := int32(0); i < awarditem.ItemNum; i++ {
+				chip := new(model.Chip)
+				chip.AccountId = user.AccountId
+				chip.ItemId = awarditem.ItemId
+				chip.ItemNum = 1
+				chip.ExpireTime = nowTime + itemcfg.GetTime()*60
+				chip.CreateTime = nowTime
+				chip.ModifyTime = nowTime
+				if chip.Create() != nil {
+					f5.GetSysLog().Error("internal error, mapgrid chip award fail:%s, %d, %d", user.AccountId, user.CurrGrid, awarditem.ItemId)
+				}
+			}
+		case constant.ITEM_TYPE_SCORE_DOUBLE_CARD:
+			fallthrough
+		case constant.ITEM_TYPE_SCORE_SMALL_GIFT_PACK:
+			fallthrough
+		case constant.ITEM_TYPE_SCORE_BIG_GIFT_PACK:
+			aa.AddItem(user.AccountId, awarditem.ItemId, awarditem.ItemNum, nil)
+			bageffect = true
+		}
+	}
+
+	return bageffect
+}

server/wheelserver/service/export.go

@@ -13,6 +13,7 @@ var Award = new(award)
 var Bag = new(bag)
 var Buff = new(buff)
 var Friend = new(friend)
+var Task = new(task)
 
 func init() {
 	global.RegModule(constant.SERVICE_MGR_MODULE_IDX, _serviceMgr)

server/wheelserver/service/task.go

@@ -0,0 +1,151 @@
+package service
+
+import (
+	"f5"
+	"main/constant"
+	"main/model"
+	"main/mt"
+	"main/vo"
+	"q5"
+)
+
+type task struct {
+}
+
+func (this *task) init() {
+}
+
+func (this *task) unInit() {
+}
+
+func (this *task) List(accountId string, data *[]*vo.Mission) (errcode int32, msg string) {
+	task := new(model.Task)
+	err, found := task.Find(accountId)
+	if err != nil {
+		return 500, "server internal error"
+	}
+
+	createTasks := true
+	nowtime := f5.GetApp().GetRealSeconds()
+	tasksupdate := false
+	newTask := func(tasks *map[int32]*model.TaskItem, taskMeta *mt.Task) {
+		taskitem := new(model.TaskItem)
+		taskitem.MissionId = taskMeta.GetId()
+		taskitem.Current = 0
+		taskitem.Target = taskMeta.GetParam1()
+		taskitem.Award = 0
+		taskitem.Time = f5.GetApp().GetRealSeconds()
+		(*tasks)[taskMeta.GetId()] = taskitem
+		tasksupdate = true
+	}
+
+	var tasks map[int32]*model.TaskItem
+	if found {
+		tasks = task.GetTaskItems()
+		if tasks != nil {
+			createTasks = false
+
+			for taskid := range tasks {
+				found := false
+				mt.Table.Task.Traverse(func(taskMeta *mt.Task) bool {
+					if taskid == taskMeta.GetId() {
+						found = true
+
+						if taskMeta.GetType() == constant.TASK_TYPE_DAILY &&
+							q5.GetDaySeconds(tasks[taskid].Time, 0) != q5.GetDaySeconds(nowtime, 0) {
+							tasks[taskid].Time = nowtime
+							tasks[taskid].Current = 0
+							tasks[taskid].Award = 0
+							tasksupdate = true
+						}
+					}
+					return true
+				})
+
+				if !found {
+					delete(tasks, taskid)
+					tasksupdate = true
+				}
+			}
+
+			mt.Table.Task.Traverse(func(taskMeta *mt.Task) bool {
+				taskid := taskMeta.GetId()
+
+				_, ok := tasks[taskid]
+				if !ok {
+					newTask(&tasks, taskMeta)
+				}
+
+				return true
+			})
+		}
+	}
+
+	if createTasks {
+		tasks = map[int32]*model.TaskItem{}
+		mt.Table.Task.Traverse(func(taskMeta *mt.Task) bool {
+			newTask(&tasks, taskMeta)
+			return true
+		})
+	}
+
+	for _, taskitem := range tasks {
+		missionVo := new(vo.Mission)
+		missionVo.FromModel(taskitem)
+		q5.AppendSlice(data, missionVo)
+	}
+
+	if tasksupdate {
+		task.UpdateTasks(tasks)
+	}
+
+	return 0, ""
+}
+
+func (this *task) UpdateTaskProgress(accountId string, itemid int32, amount int32, data *[]*vo.Mission) (errcode int32, msg string) {
+	task := new(model.Task)
+	err, found := task.Find(accountId)
+	if err != nil || !found {
+		return 500, "server internal error"
+	}
+
+	tasks := task.GetTaskItems()
+	if tasks == nil {
+		return 401, "bad request"
+	}
+
+	taskupdate := false
+	for _, taskitem := range tasks {
+		if taskitem.Award != 0 || taskitem.Current >= taskitem.Target {
+			continue
+		}
+
+		taskMeta := mt.Table.Task.GetById(int64(taskitem.MissionId))
+		if taskMeta == nil {
+			continue
+		}
+
+		if taskMeta.GetParam2() != itemid {
+			continue
+		}
+
+		taskitem.Current += amount
+		if taskitem.Current > taskitem.Target {
+			taskitem.Current = taskitem.Target
+		}
+
+		taskupdate = true
+	}
+
+	if taskupdate {
+		task.UpdateTasks(tasks)
+	}
+
+	for _, taskitem := range tasks {
+		missionVo := new(vo.Mission)
+		missionVo.FromModel(taskitem)
+		q5.AppendSlice(data, missionVo)
+	}
+
+	return 0,""
+}