RoServer/RO_Server_Trunk-branch_bt/roserver/game/model/role_wishBox.go

package model

import (
	"math/rand"
	"rocommon/util"
	"roserver/baseserver/model"
	"roserver/serverproto"
)

func newRoleWish(r *Role) *RoleWishBox {
	roleCommon := &RoleWishBox{
		SaveObject: SaveObject{
			role: r,
		},
	}
	return roleCommon
}

type WishSlotInfo struct {
	*serverproto.WishSlot

	//srcDb *model.StDbWishBox
}

func (this WishSlotInfo) HasLucky() bool {
	srcDb, ok := model.ConvertWishBoxData[this.SrcItem]
	if !ok {
		util.ErrorF("WishSlotInfo HasLucky error srcDb == nil")
		return false
	}

	value := rand.Int31n(100)
	return value <= srcDb.LuckyProb
}

func (this WishSlotInfo) GetLuckyItem() (item *serverproto.KeyValueType) {
	srcDb, ok := model.ConvertWishBoxData[this.SrcItem]
	if !ok {
		util.ErrorF("WishSlotInfo GetLuckyItem error srcDb == nil")
		return nil
	}
	item = &serverproto.KeyValueType{}
	value := rand.Int31n(srcDb.LuckyReward[len(srcDb.LuckyReward)-1].Weight)
	for _, data := range srcDb.LuckyReward {
		if value > data.Weight {
			continue
		}
		item.Key = data.ItemId
		item.Value = data.ItemCnt
		break
	}
	return
}

func (this WishSlotInfo) GetRewardItem(itemId int32) (ret *model.StProbRewardData) {
	srcDb, ok := model.ConvertWishBoxData[this.SrcItem]
	if !ok {
		util.ErrorF("WishSlotInfo GetRewardItem error srcDb == nil")
		return nil
	}
	for _, i2 := range srcDb.RewardList {
		if i2.ItemId != itemId {
			continue
		}
		ret = i2
		break
	}
	return
}

func (this WishSlotInfo) GetRandRewardItem() (ret *model.StProbRewardData) {
	srcDb, ok := model.ConvertWishBoxData[this.SrcItem]
	if !ok {
		util.ErrorF("WishSlotInfo GetRandRewardItem error srcDb == nil")
		return nil
	}
	total := srcDb.RewardList[len(srcDb.RewardList)-1].Weight
	value := rand.Int31n(total)
	for _, i2 := range srcDb.RewardList {
		if value > i2.Weight {
			continue
		}
		ret = i2
		break
	}
	return
}

type RoleWishBox struct {
	SaveObject
	slot []*WishSlotInfo
}

func (this *RoleWishBox) Load(msg interface{}) bool {
	proRole := msg.(*serverproto.Role)
	wish := proRole.RoleWish
	if wish == nil {
		return false
	}
	for _, data := range wish.Slots {
		this.slot = append(this.slot, &WishSlotInfo{WishSlot: data})
	}
	util.InfoF("uid=%v RoleWishBox Load .. list=%v", this.role.GetUUid(), this.slot)
	return true
}

func (this *RoleWishBox) Save() {
	this.SetDirty(false)
	saveMsg := &serverproto.SSWishBoxDataSaveReq{Wishs: &serverproto.RoleWish{}}
	for _, data := range this.slot {
		saveMsg.Wishs.Slots = append(saveMsg.Wishs.Slots, data.WishSlot)
	}
	this.role.SendDb(saveMsg)
}

func (this *RoleWishBox) CopyData(wish *serverproto.RoleWish) {
	for _, data := range this.slot {
		wish.Slots = append(wish.Slots, data.WishSlot)
	}
}

// 许愿
func (this *RoleWishBox) OnWishBoxUse(itemId uint64, selectItem int32) (serverproto.ErrorCode, int32) {
	index := int32(-1)
	if itemId <= 0 {
		return serverproto.ErrorCode_ERROR_FAIL, index
	}

	item := this.role.roleBag.getItemById(itemId)
	if item == nil {
		return serverproto.ErrorCode_ERROR_WISH_BOX_NOT_ITEM, index
	}
	if !this.hasSlot() {
		return serverproto.ErrorCode_ERROR_WISH_NOT_SLOT, index
	}
	dbData, ok := model.ConvertWishBoxData[item.ConfigId]
	if !ok {
		return serverproto.ErrorCode_ERROR_WISH_NOT_WISHBOX, index
	}
	reward := dbData.GetRewardItem(selectItem)
	if !dbData.IsRand && reward == nil {
		return serverproto.ErrorCode_ERROR_WISH_NOT_ITEM, index
	}
	if reward == nil {
		reward = dbData.GetRandRewardItem()
	}
	//this.role.DelItem(item.ConfigId, 1, AddItemST{AddFrom: AddFrom_WishBoxUse, Notify: true})

	index = this.AddSlotItem(reward, dbData)
	if index < 0 {
		return serverproto.ErrorCode_ERROR_FAIL, index
	}
	this.role.DelItem(item.ConfigId, 1, AddItemST{AddFrom: AddFrom_WishBoxUse, Notify: true})
	this.SendWishSlot()
	this.SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK, index
}

// 解锁许愿槽位
func (this *RoleWishBox) OnUnlockWishSlot() serverproto.ErrorCode {
	if int32(len(this.slot)) >= model.GlobalWishSlotMaxCnt {
		return serverproto.ErrorCode_ERROR_WISH_ALL_UNLOCK
	}
	if !this.role.roleBag.CanDelItem(model.GlobalWishSlotCost.Key, model.GlobalWishSlotCost.Value) {
		return serverproto.ErrorCode_ERROR_RES_NOT_ENOUGH
	}

	this.role.DelItem(model.GlobalWishSlotCost.Key, model.GlobalWishSlotCost.Value, AddItemST{AddFrom: AddFrom_WishBox})

	this.slot = append(this.slot, &WishSlotInfo{WishSlot: &serverproto.WishSlot{IsOpen: true}})
	this.SendWishSlot()
	this.SetDirty(true)
	return serverproto.ErrorCode_ERROR_OK
}

// 领取许愿奖励
func (this *RoleWishBox) OnWishRewardGet(index int32) (error serverproto.ErrorCode, awardItem *serverproto.KeyValueType, luckyItem *serverproto.KeyValueType) {
	error = serverproto.ErrorCode_ERROR_OK
	if index < 0 || index > int32(len(this.slot))-1 {
		return serverproto.ErrorCode_ERROR_FAIL, nil, nil
	}
	rewardItem := this.slot[index]
	if rewardItem.Item == nil {
		return serverproto.ErrorCode_ERROR_WISH_SLOT_NOT_ITEM, nil, nil
	}
	if rewardItem.EndTime > util.GetTimeSeconds() {
		// 加速
		dbData, ok := model.ConvertWishBoxData[rewardItem.SrcItem]
		if !ok {
			return serverproto.ErrorCode_ERROR_FAIL, nil, nil
		}
		if !this.role.roleBag.CanDelItem(dbData.SpeedCost.Key, dbData.SpeedCost.Value) {
			return serverproto.ErrorCode_ERROR_WISH_NOT_SPEED_ITEM, nil, nil
		}
		this.role.DelItem(dbData.SpeedCost.Key, dbData.SpeedCost.Value, AddItemST{AddFrom: AddFrom_WishBoxSpeed})
		rewardItem.IsLucky = rewardItem.HasLucky()
	}
	// 判断许愿奖励
	if rewardItem.Item != nil && this.role.roleBag.CanAddItem(rewardItem.Item.Key, rewardItem.Item.Value) == serverproto.ErrorCode_ERROR_OK {
		this.role.roleBag.AddItem(rewardItem.Item.Key, rewardItem.Item.Value, AddItemST{AddFrom: AddFrom_WishBox, Notify: true})
	}

	// 是否有暴击物品
	if rewardItem.IsLucky {
		if item := rewardItem.GetLuckyItem(); item != nil {
			this.role.roleBag.AddItem(item.Key, item.Value, AddItemST{AddFrom: AddFrom_WishBox, Notify: true})
			luckyItem = item
		}
	}
	awardItem = rewardItem.Item
	this.clearSlot(index)
	this.SendWishSlot()
	this.SetDirty(true)
	return
}

func (this *RoleWishBox) Update(ms uint64) {
	updateMsg := false
	sec := int64(ms / 1000)
	for _, data := range this.slot {
		if data.EndTime <= 0 {
			continue
		}
		if data.EndTime > sec {
			continue
		}
		data.EndTime = 0
		updateMsg = true
		data.IsLucky = data.HasLucky()
		this.SetDirty(true)
	}
	if updateMsg {
		this.SendWishSlot()
	}
}

func (this *RoleWishBox) AddSlotItem(itemInfo *model.StProbRewardData, srcDb *model.StDbWishBox) (index int32) {
	if itemInfo == nil {
		return -1
	}
	index = -1
	for i, slot := range this.slot {
		if slot.Item != nil {
			continue
		}
		if !slot.IsOpen {
			continue
		}
		slot.SrcItem = srcDb.ItemId
		//slot.srcDb = srcDb
		slot.Item = &serverproto.KeyValueType{Key: itemInfo.ItemId, Value: itemInfo.ItemCnt}
		slot.EndTime = int64(itemInfo.WaitTime) + util.GetTimeSeconds()
		index = int32(i)
		break
	}
	return index
}

//func (this *RoleWishBox) AddSlotItem(itemId, selectItem int32) (index int32) {
//	if itemId <= 0 ||  selectItem <= 0{
//		return -1
//	}
//	dbData, ok := model.ConvertWishBoxData[itemId]
//	if !ok{
//		return -1
//	}
//	//reward := dbData.GetRewardItem(selectItem)
//	//if !dbData.IsRand && reward == nil{
//	//	return serverproto.ErrorCode_ERROR_WISH_NOT_ITEM, index
//	//}
//	//if reward == nil{
//	//	reward = dbData.GetRandRewardItem()
//	//}
//	index = -1
//	for i, slot := range this.slot {
//		if slot.Item != nil{continue}
//		if !slot.IsOpen{continue}
//		slot.SrcItem = itemId
//		if dbData.IsRand{
//			Award := slot.GetRandRewardItem()
//		}
//		slot.Item = &serverproto.KeyValueType{Key: itemInfo.ItemId, Value: itemInfo.ItemCnt}
//		slot.EndTime = int64(itemInfo.WaitTime) + util.GetTimeSeconds()
//		index = int32(i)
//		break
//	}
//	return index
//}

func (this *RoleWishBox) clearSlot(index int32) {
	if len(this.slot) < int(index) {
		return
	}
	this.slot[index].Reset()
	this.slot[index].IsOpen = true
}

func (this RoleWishBox) SendWishSlot() {
	msg := &serverproto.SCUpdateWishSlotNtf{}
	for _, data := range this.slot {
		msg.Slots = append(msg.Slots, data.WishSlot)
	}
	this.role.ReplayGate(msg, true)
}

func (this RoleWishBox) hasSlot() bool {
	for _, slot := range this.slot {
		if slot.Item != nil {
			continue
		}
		if !slot.IsOpen {
			continue
		}
		return true
	}
	return false
}