bl/logic/service/player/Monster.go

package player

import (
	"blazing/common/data/xmlres"
	"blazing/logic/service/common"
	"strings"
	"sync/atomic"

	"github.com/gogf/gf/v2/util/gconv"
	"github.com/gogf/gf/v2/util/grand"
)

// 2. 从 string 类型 slice 随机选一个元素
func RandomStringFromSlice(s []string) string {

	randomIdx := grand.Intn(len(s))
	return s[randomIdx]
}

// 刷怪具体实现
func (p *Player) SpawnMonsters() {
	// 获取当前地图的怪物配置

	// 创建数据包
	tt := common.NewTomeeHeader(2004, p.Info.UserID)

	p.genMonster() //生成野怪

	p.SendPack(tt.Pack(&p.OgreInfo))

}

// 应该根据怪物信息决定后端生成
func (p *Player) genMonster() {
	var oldnum, newNum int
	p.monsters, oldnum, newNum = replaceOneNumber(p.monsters)
	// 设置怪物信息
	t1 := OgreInfo{}
	mapss, ok := xmlres.MonsterMap[gconv.Int(p.Info.MapID)]

	if ok && mapss.Monsters != nil {
		ok, _, _ := p.PlayerCaptureContext.Roll(mapss.Monsters.WildBonusProb, mapss.Monsters.WildBonusTotalProb)
		for i, m := range mapss.Monsters.Monsters { //这里是9个
			id := strings.Split(m.ID, " ")
			lv := strings.Split(m.Lv, " ")

			ttt := OgrePetInfo{}
			ttt.Id = gconv.Uint32(RandomStringFromSlice(id))

			if ttt.Id != 0 {

				ttt.Lv = gconv.Uint32(RandomStringFromSlice(lv))
				if grand.Meet(1, 100) {
					ttt.RandSHiny()
				}

				if len(id) == 1 { //说明这里只固定刷一个，概率变尼尔尼奥

					// nier, _, _ := p.Roll(10, 1000)
					// if nier {
					// 	ttt.Ext = 77

					// }

					nieo, _, _ := p.Roll(20, 1000)
					if nieo {
						ttt.Ext = 77
						if grand.Meet(1, 2) {
							ttt.Ext = 416
						}

						ttt.Lv = 16
					}

				}
				if ok {

					ttt.Item = uint32(mapss.Monsters.ItemBonusID)

				}
			}

			t1.Data[i] = ttt

		}

	}

	if atomic.CompareAndSwapUint32(&p.Canmon, 2, 1) {
		p.OgreInfo = OgreInfo{} //切地图清空
		for i := 0; i < 3; i++ {

			p.OgreInfo.Data[p.monsters[i]] = t1.Data[p.monsters[i]]
		}
	}
	p.OgreInfo.Data[oldnum] = OgrePetInfo{}
	p.OgreInfo.Data[newNum] = t1.Data[newNum]

}

// 生成0-9之间三个不重复的随机数 进地图5s
func generateThreeUniqueNumbers() [3]int {

	selected := make(map[int]bool)
	var result [3]int
	index := 0

	for index < 3 {
		num := grand.Intn(9)
		if !selected[num] {
			selected[num] = true
			result[index] = num
			index++
		}
	}
	return result
}

// 从三个数字中移除一个，并从剩余6个数字中选一个补充 10s
func replaceOneNumber(original [3]int) ([3]int, int, int) {
	// 随机选择要移除的索引（0-2）
	removeIndex := grand.Intn(3)
	removedNum := original[removeIndex]

	// 找出所有不在原始数组中的数字（候选数字）
	candidates := []int{}
	originalMap := make(map[int]bool)
	for _, num := range original {
		originalMap[num] = true
	}

	for i := 0; i < 8; i++ {
		if !originalMap[i] {
			candidates = append(candidates, i)
		}
	}

	// 从候选数字中随机选择一个
	newNum := candidates[grand.Intn(len(candidates))]

	// 创建新数组并替换数字
	newNumbers := original
	newNumbers[removeIndex] = newNum

	return newNumbers, removedNum, newNum
}

func GenerateNormalizedColorMatrix() [20]uint8 {
	var matrix [20]uint8

	// ---------- R/G/B 通道：仅用 grand.N 生成整数（归一化映射） ----------
	// 生成权重（0~51）：对应归一化系数 0.0~0.2（不会溢出）
	genWeight := func() uint8 { return uint8(grand.N(0, 2)) }
	// 生成偏移（0~25）：对应归一化系数 0.0~0.1（不会溢出）
	genOffset := func() uint8 { return uint8(grand.N(0, 2)) }

	// R 通道（索引0-4）
	matrix[0] = genWeight()
	matrix[1] = genWeight()
	matrix[2] = genWeight()
	matrix[3] = genWeight()
	matrix[4] = genOffset()

	// G 通道（索引5-9）
	matrix[5] = genWeight()
	matrix[6] = genWeight()
	matrix[7] = genWeight()
	matrix[8] = genWeight()
	matrix[9] = genOffset()

	// B 通道（索引10-14）
	matrix[10] = genWeight()
	matrix[11] = genWeight()
	matrix[12] = genWeight()
	matrix[13] = genWeight()
	matrix[14] = genOffset()

	// ---------- A 通道：固定归一化值（无随机） ----------
	matrix[15] = 0 // 归一化系数 0.0
	matrix[16] = 0 // 归一化系数 0.0
	matrix[17] = 0 // 归一化系数 0.0
	matrix[18] = 1 // 归一化系数 1.0（透明度权重不变）
	matrix[19] = 0 // 归一化系数 0.0

	return matrix
}