ro-webgl-server/server/roserver/fruit/model/fruit_room.go

package model

import (
	"log"
	"math/rand"
	"rocommon/util"
	"roserver/serverproto"
)

const (
	ROOM_STAGE_BET      = 1 //押注阶段
	ROOM_STAGE_SETTLE   = 2 //开奖阶段
	DURATION_BET_SEC    = 2
	DURATION_SETTLE_SEC = 1
	MAX_POOL_CHIP       = 10000
	AWARD_TYPE_NORMAL   = 1
	AWARD_TYPE_SPECIAL  = 2
)

type FruitRoom struct {
	roomId       int32
	stage        int32
	sec          int32
	uidList      []uint64
	PoolChipNum  uint32
	TotalBetInfo map[int32]int32
}

type FruitRateInfo struct {
	AwardType int32
	Rate      int32
	D_Rate    int32
	Z_Rate    int32
	FinalRate int32
}

func newFruitRoom(roomId int32) *FruitRoom {
	room := &FruitRoom{
		roomId:       roomId,
		stage:        ROOM_STAGE_BET,
		sec:          0,
		uidList:      make([]uint64, 0),
		PoolChipNum:  0,
		TotalBetInfo: make(map[int32]int32),
	}
	room.ResetTotalBetInfo()
	return room
}

func (self *FruitRoom) ResetTotalBetInfo() {
	var i int32
	for i = 1; i <= 8; i++ {
		self.TotalBetInfo[i] = 0
	}
}

func (self *FruitRoom) Join(uid uint64) {
	isExist := false
	for _, v := range self.uidList {
		if v == uid {
			isExist = true
		}
	}
	if isExist == false {
		self.uidList = append(self.uidList, uid)
	}
}

func sliceRemoveValueFast(slice []uint64, value uint64) []uint64 {
	for i := 0; i < len(slice); {
		if slice[i] == value {
			slice[i] = slice[len(slice)-1]
			slice = slice[:len(slice)-1]
		} else {
			i++
		}
	}
	return slice
}
func (self *FruitRoom) Leave(uid uint64) {
	self.uidList = sliceRemoveValueFast(self.uidList, uid)
}

func (self *FruitRoom) Bet(uid uint64, betInfo []*serverproto.FruitSlotBetInfo) serverproto.ErrorCode {
	if self.stage != ROOM_STAGE_BET {
		return serverproto.ErrorCode_ERROR_FRUIT_CURR_STAGE_CANNOT_BET
	}
	player := FruitMgr.GetPlayer(uid)
	for _, v := range betInfo {
		slot := v.Slot
		betNum := v.BetNum
		if player.ChipNum >= betNum {
			player.ChipNum -= betNum
			player.CurrBetInfo[slot] += betNum
			self.TotalBetInfo[slot] += betNum
			self.PoolChipNum += uint32(betNum)
		} else {
			return serverproto.ErrorCode_ERROR_FRUIT_CHIP_INSUFFICIENT
		}
	}
	return serverproto.ErrorCode_ERROR_OK
}

func (self *FruitRoom) JumpStage(stage int32) {
	self.stage = stage
	self.sec = 0
	switch stage {
	case ROOM_STAGE_BET:
	case ROOM_STAGE_SETTLE:
		self.Settle()
	}
}

// 开奖
func (self *FruitRoom) Roll(rateItems []*FruitRateInfo) *FruitRateInfo {
	var sumRate int32 = 0
	for i := 0; i < len(rateItems); i++ {
		rateItems[i].FinalRate = rateItems[i].Rate + rateItems[i].D_Rate*int32(self.PoolChipNum)/MAX_POOL_CHIP
		sumRate += rateItems[i].FinalRate
	}
	randomVal := rand.Int31n(sumRate)
	var tmpSumRate int32 = 1
	for i := 0; i < len(rateItems); i++ {
		tmpSumRate += rateItems[i].FinalRate
		if randomVal <= tmpSumRate {
			return rateItems[i]
		}
	}
	util.InfoF("ERR: Roll Fail, Use the First Element")
	return rateItems[0]
}

func (self *FruitRoom) Settle() {
	// 1. first roll: normal award or special award
	rollResult := self.Roll([]*FruitRateInfo{
		&FruitRateInfo{AwardType: AWARD_TYPE_NORMAL, Rate: 9300, D_Rate: 150},
		&FruitRateInfo{AwardType: AWARD_TYPE_SPECIAL, Rate: 700, D_Rate: 200},
	})
	log.Println("AwardType: ", rollResult.AwardType)
	//cfg := serverproto.FruitSlotTypeCfgLoader[1]
	//for i := 0; i < len(self.uidList); i++ {
	//	uid := self.uidList[i]
	//	player := FruitMgr.GetPlayer(uid)
	//}
}

func (self *FruitRoom) SecTick() {
	totalBetInfo := make([]*serverproto.FruitSlotBetInfo, 0)
	var i int32
	for i = 1; i <= 8; i++ {
		slotTotalBetNum := self.TotalBetInfo[i]
		totalBetInfo = append(totalBetInfo, &serverproto.FruitSlotBetInfo{
			Slot:   i,
			BetNum: slotTotalBetNum,
		})
	}
	ntfMsg := &serverproto.SCFruitSecTickNtf{
		Sec:          self.sec,
		PoolChipNum:  self.PoolChipNum,
		TotalBetInfo: totalBetInfo,
	}
	SendToAllGameWithUidList(ntfMsg, self.uidList)
}

func (self *FruitRoom) Update() {
	if len(self.uidList) == 0 {
		//return
	}

	self.sec++
	//log.Println(self.stage, self.sec)

	switch self.stage {
	case ROOM_STAGE_BET:
		if self.sec > DURATION_BET_SEC {
			self.JumpStage(ROOM_STAGE_SETTLE)
			break
		}
		self.SecTick()

	case ROOM_STAGE_SETTLE:
		if self.sec > DURATION_SETTLE_SEC {
			self.JumpStage(ROOM_STAGE_BET)
			break
		}
	}

}