feat: 重构任务奖励系统并增加宠物技能和皮肤奖励

将任务奖励逻辑重构到单独的文件中，增加对宠物技能和皮肤奖励的支持，优化任务完成处理流程

modules/config/model/glow.go

@@ -71,6 +71,10 @@ func roundFloat32(val float32, decimals int) float32 {
 	return float32(math.Round(float64(val*shift))) / shift
 }
 
+func randomFloat32Range(r *rand.Rand, min, max float32) float32 {
+	return min + float32(r.Float64())*(max-min)
+}
+
 // 预处理矩阵：自动修正越界参数，确保合规
 func ProcessOffspringMatrix(mat [4][5]float32) [4][5]float32 {
 	var processedMat [4][5]float32
@@ -118,71 +122,62 @@ func calculateMatrixHash(mm MonsterMatrix) string {
 	return hex.EncodeToString(h.Sum(nil))
 }
 
-// GenerateRandomParentMatrix 调整随机参数范围，解决暗色问题，贴合你的示例
+// GenerateRandomParentMatrix 生成色域更大的父矩阵，同时抬高黑场避免整只精灵发黑
 func GenerateRandomParentMatrix() MonsterMatrix {
-	// 1. 保留高熵种子逻辑（确保唯一性，不变）
 	salt := "player-matrix-random-seed"
 	now := time.Now().UnixNano()
 	randomNum := rand.Int63()
 	seed := now ^ randomNum ^ int64(hashString(salt))
 	r := rand.New(rand.NewSource(seed))
 
-	// 2. 调整随机参数范围（贴合你的示例，解决暗色问题）
-	// 对比你的示例：亮度大多在[-30,30]，对比度[0.7,1.7]，饱和度[0.4,1.4]，偏移[-10,10]
-	params := struct {
-		brightness float32 // 从[-125,125]调整为[-30,60]，避免过低亮度
-		contrast   float32 // 从[0.4,2.2]调整为[0.7,1.7]，贴合你的示例
-		saturation float32 // 从[0.1,2.0]调整为[0.4,1.4]，避免低饱和度灰暗
-		hueRotate  float32 // 从[-180,180]调整为[-50,50]，减少极端色相导致的暗沉
-		rOffset    float32 // 从[-50,50]调整为[-10,10]，避免亮度偏移过大
-		gOffset    float32 // 同上
-		bOffset    float32 // 同上
-	}{
-		brightness: float32(r.Float64()*90 - 30),   // [-30, 60]（贴合示例亮度范围，减少暗色）
-		contrast:   float32(r.Float64()*1.0 + 0.7), // [0.7, 1.7]（与你的示例完全匹配）
-		saturation: float32(r.Float64()*1.0 + 0.4), // [0.4, 1.4]（与你的示例完全匹配）
-		hueRotate:  float32(r.Float64()*100 - 50),  // [-50, 50]（避免极端色相）
-		rOffset:    float32(r.Float64()*20 - 10),   // [-10, 10]（小幅亮度偏移，贴合示例）
-		gOffset:    float32(r.Float64()*20 - 10),   // 同上
-		bOffset:    float32(r.Float64()*20 - 10),   // 同上
+	matrix := newIdentityMatrix()
+	dominant := r.Intn(3)
+	accent := (dominant + 1 + r.Intn(2)) % 3
+	baseLift := randomFloat32Range(r, 10, 24)
+
+	for row := 0; row < 3; row++ {
+		for col := 0; col < 3; col++ {
+			value := randomFloat32Range(r, -0.22, 0.22)
+			if row == col {
+				value = randomFloat32Range(r, 0.8, 1.45)
+			}
+			if row == dominant && col == dominant {
+				value += randomFloat32Range(r, 0.35, 0.7)
+			}
+			if row == accent && col == accent {
+				value += randomFloat32Range(r, 0.1, 0.3)
+			}
+			if row == dominant && col != row {
+				value += randomFloat32Range(r, -0.12, 0.28)
+			}
+			matrix[row][col] = clampFloat32(roundFloat32(value, FloatPrecision), MatrixMinVal, MatrixMaxVal)
+		}
 	}
 
-	// 3. 矩阵计算逻辑不变（确保与你的示例参数分布一致）
-	matrix := newIdentityMatrix()
-	contrast := params.contrast
-	matrix[0][0] *= contrast
-	matrix[1][1] *= contrast
-	matrix[2][2] *= contrast
+	matrix[0][4] = baseLift + randomFloat32Range(r, -5, 10)
+	matrix[1][4] = baseLift + randomFloat32Range(r, -5, 10)
+	matrix[2][4] = baseLift + randomFloat32Range(r, -5, 10)
+	matrix[dominant][4] += randomFloat32Range(r, 8, 18)
+	matrix[accent][4] += randomFloat32Range(r, 2, 8)
 
-	sat := params.saturation
-	grayR, grayG, grayB := float32(0.299)*(1-sat), float32(0.587)*(1-sat), float32(0.114)*(1-sat)
-	matrix[0][0] = grayR + sat*matrix[0][0]
-	matrix[0][1], matrix[0][2] = grayG, grayB
-	matrix[1][0] = grayR
-	matrix[1][1] = grayG + sat*matrix[1][1]
-	matrix[1][2] = grayB
-	matrix[2][0] = grayR
-	matrix[2][1] = grayG
-	matrix[2][2] = grayB + sat*matrix[2][2]
+	avgBrightness := (matrix[0][4] + matrix[1][4] + matrix[2][4]) / 3
+	if avgBrightness < 12 {
+		lift := 12 - avgBrightness + randomFloat32Range(r, 0, 6)
+		for row := 0; row < 3; row++ {
+			matrix[row][4] += lift
+		}
+	}
+	if matrix[dominant][4] < 16 {
+		matrix[dominant][4] = 16 + randomFloat32Range(r, 0, 10)
+	}
 
-	angle := params.hueRotate * float32(math.Pi) / 180
-	cos, sin := float32(math.Cos(float64(angle))), float32(math.Sin(float64(angle)))
-	r1, g1, b1 := matrix[0][0], matrix[0][1], matrix[0][2]
-	r2, g2, b2 := matrix[1][0], matrix[1][1], matrix[1][2]
+	for row := 0; row < 3; row++ {
+		for col := 0; col < 3; col++ {
+			matrix[row][col] = clampFloat32(roundFloat32(matrix[row][col], FloatPrecision), MatrixMinVal, MatrixMaxVal)
+		}
+		matrix[row][4] = clampFloat32(roundFloat32(matrix[row][4], FloatPrecision), BrightnessMinVal, BrightnessMaxVal)
+	}
 
-	matrix[0][0] = r1*cos - r2*sin
-	matrix[0][1] = r1*sin + r2*cos
-	matrix[1][0] = g1*cos - g2*sin
-	matrix[1][1] = g1*sin + g2*cos
-	matrix[2][0] = b1*cos - b2*sin
-	matrix[2][1] = b1*sin + b2*cos
-
-	// 亮度偏移：范围缩小后，避免过暗/过亮
-	matrix[0][4] = params.brightness + params.rOffset
-	matrix[1][4] = params.brightness + params.gOffset
-	matrix[2][4] = params.brightness + params.bOffset
-
-	// 4. 封装为MonsterMatrix（不变）
 	parent := MonsterMatrix{
 		Matrix:  matrix,
 		Hash:    "",