pet_home_server/src/server/conf/mergeData/MergeDataCfg.go

package mergeDataCfg

import (
	"errors"
	"server/GoUtil"
	"server/game/mod/item"
	"server/gamedata"
	"server/pkg/github.com/name5566/leaf/log"
	"strconv"
	"strings"
)

const (
	CFG_NAME            = "MergeData"
	CONST_NAME          = "MergeDataConst"
	CFG_MERGE_EMIT      = "MergeDataEmit"
	CFG_MERGE_EMIT_TYPE = "MergeDataEmitType"
	CFG_MERGE_COLOR     = "MergeDataColor"

	// 棋子类型
	CHESS_PRODUCT_MAIN_TYPE      = 1 // 主产物
	CHESS_PRODUCT_SECONDARY_TYPE = 2 // 次产物
	CHESS_PRODUCT_SUB_TYPE       = 3 // 子发射器产物
)

func init() {
	gamedata.InitCfg(CFG_NAME)
	gamedata.InitCfg(CONST_NAME)
	gamedata.InitCfg(CFG_MERGE_EMIT)
	gamedata.InitCfg(CFG_MERGE_EMIT_TYPE)
	gamedata.InitCfg(CFG_MERGE_COLOR)
}

func GetEmitTypeProduce(EmitType string) []string {
	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT_TYPE, EmitType)
	if err != nil {
		// log.Debug("GetEmitTypeProduce GetOne EmitType:%s not found", EmitType)
		return []string{}
	}
	return strings.Split(gamedata.GetStringValue(data, "Produce"), ",")
}

func GetEmitTypeByColor(Color string) string {
	data, err := gamedata.GetData(CFG_MERGE_EMIT)
	if err != nil {
		return ""
	}
	for k, v := range data {
		ColorList := strings.Split(gamedata.GetStringValue(v, "Order_Type"), ",")
		if GoUtil.InStringArray(Color, ColorList) {
			return k
		}
	}
	return ""
}

func GetEmitProduce(EmitType string) []string {
	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, EmitType)
	if err != nil {
		log.Debug("GetEmitProduce GetOne EmitType:%s not found", EmitType)
		return []string{}
	}
	return strings.Split(gamedata.GetStringValue(data, "Product_Type"), ",")
}

func GetEmitOrderProduce(EmitType string) []string {
	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, EmitType)
	if err != nil {
		log.Debug("GetEmitProduce GetOne EmitType:%s not found", EmitType)
		return []string{}
	}
	return strings.Split(gamedata.GetStringValue(data, "Order_Type"), ",")
}

// 获取单个数据
func GetOne(Id int) (*gamedata.MergeDataRecord, error) {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("MergeDataCfg GetOne Id:%v not found", Id)
		return &gamedata.MergeDataRecord{}, errors.New("not found")
	}
	return &gamedata.MergeDataRecord{
		Id:           gamedata.ParseInt(data["Id"]),
		Lv:           gamedata.ParseInt(data["Lv"]),
		MaxLv:        gamedata.ParseInt(data["MaxLv"]),
		SellType:     gamedata.ParseString(data["SellType"]),
		SellNum:      gamedata.ParseInt(data["SellNum"]),
		SellDiamond:  gamedata.ParseInt(data["SellDiamond"]),
		Color:        gamedata.ParseString(data["Color"]),
		Star:         gamedata.ParseInt(data["Star"]),
		Type:         gamedata.ParseString(data["Type"]),
		Emit_Product: gamedata.ParseString(data["Emit_Product"]),
		CoolTime:     gamedata.ParseInt(data["CoolTime"]),
	}, nil
}

// 根据id获取棋子获得的星星
func GetStarById(Id int) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("MergeDataCfg GetOne Id:%v not found", Id)
		return 0
	}
	return gamedata.ParseInt(data["Star"])
}

func GetNameById(Id int) string {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("MergeDataCfg GetOne Id:%v not found", Id)
		return ""
	}
	return gamedata.GetStringValue(data, "Title")
}

// 根据等级和颜色获取棋子id
func GetChessIdByLvAndColor(Lv int, Color string) int {
	if Lv == 0 || Color == "" {
		return 0
	}
	data, err := gamedata.GetData(CFG_NAME)
	if err != nil {
		// log.Debug("MergeDataCfg GetChessIdByLvAndColor lv:%v Color:%v not found", Lv, Color)
		return 0
	}
	for k, v := range data {
		lv := gamedata.GetIntValue(v, "Lv")
		color := gamedata.GetStringValue(v, "Color")
		if Lv == lv && color == Color {
			Id, _ := strconv.Atoi(k)
			return Id
		}
	}
	// log.Debug("MergeDataCfg GetChessIdByLvAndColor lv:%v Color:%v not found", Lv, Color)
	return 0
}

// 根据Id获取棋子等级
func GetLvById(Id int) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("GetLvById GetOne Id:%v not found", Id)
		return 0
	}
	return gamedata.ParseInt(data["Lv"])
}

// 根据Id获取棋子最大等级
func GetMaxLvById(Id int) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("GetMaxLvById GetOne Id:%v not found", Id)
		return 0
	}
	return gamedata.ParseInt(data["MaxLv"])
}

// 根据Id获取棋子最大等级
func GetMaxLvByColor(Color string) int {
	ChessId := GetChessIdByLvAndColor(1, Color)
	data, err := gamedata.GetDataByIntKey(CFG_NAME, ChessId)
	if err != nil {
		return 0
	}
	return gamedata.ParseInt(data["MaxLv"])
}

// 根据Id获取发射器最小等级
func GetEmitMinLvById(Id string) int {
	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
	if err != nil {
		log.Debug("GetEmitMinLvById GetOne Id:%v not found", Id)
		return 0
	}
	return gamedata.GetIntValue(data, "Emit_Min_Lv")
}

// 根据Id获取发射器修正系数
func GetEmitRatio(Id string) float64 {
	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
	if err != nil {
		log.Debug("GetEmitRatio GetOne Id:%v not found", Id)
		return 0
	}
	return gamedata.GetFloatValue(data, "Ratio")
}

func GetEmitRetire(Id string) int {
	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, Id)
	if err != nil {
		log.Debug("GetEmitRetire GetOne Id:%v not found", Id)
		return 0
	}
	return gamedata.GetIntValue(data, "Retire")
}

// 根据Id获取棋子类型
func GetTypeById(Id int) string {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("GetTypeById GetOne Id:%v not found", Id)
		return ""
	}
	return gamedata.ParseString(data["Type"])
}

// 根据Id获取棋子类型
func GetColorById(Id int) string {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("GetColorById GetOne Id:%v not found", Id)
		return ""
	}
	return gamedata.ParseString(data["Color"])
}

// 根据Id获取棋子类型
func GetSellNumById(Id int) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("GetSellNumById GetOne Id:%v not found", Id)
		return 0
	}
	return gamedata.GetIntValue(data, "SellNum")
}

// 根据Id获取发射器产出类型
func GetEmitProduceType(Id int) []string {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("GetEmitProduceType GetOne Id:%v not found", Id)
		return []string{}
	}
	return strings.Split(gamedata.ParseString(data["Emit_Product"]), ",")
}

// 根据Id获取发射器产出类型
func GetEmitProduceChessType(Id int) []string {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		//log.Debug("GetEmitProduceChessType GetOne Id:%v not found", Id)
		return []string{}
	}
	value := gamedata.ParseString(data["Product_Type"])
	if value == "" {
		return []string{}
	}
	return strings.Split(value, ",")
}

// 根据Id获取发射器Id
func GetEmitId(Id int) string {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("GetEmitId GetOne Id:%v not found", Id)
		return ""
	}
	return gamedata.ParseString(data["Emit_ID"])
}

func GetAllId() []int {
	data, err := gamedata.GetData(CFG_NAME)
	if err != nil {
		return []int{}
	}
	key := make([]int, 0)
	for k := range data {
		key = append(key, GoUtil.Int(k))
	}
	return key
}

func GetEmitType(Id int) string {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, Id)
	if err != nil {
		log.Debug("GetEmitType GetOne Id:%v not found", Id)
		return ""
	}
	return gamedata.ParseString(data["Emit_Type"])
}

func GetEmitN(EmitSeries string) int {
	data, err := gamedata.GetDataByKey(CFG_MERGE_EMIT, EmitSeries)
	if err != nil {
		log.Debug("GetEmitN GetOne EmitSeries:%v not found", EmitSeries)
		return 0
	}
	return gamedata.GetIntValue(data, "N")
}

// 获取常量
func GetConst(Key string) string {
	data, err := gamedata.GetDataByKey(CONST_NAME, Key)
	if err != nil {
		log.Debug("GetConst GetOne Id:%s not found", Key)
		return ""
	}
	return gamedata.ParseString(data["Value"])
}

// 获取常量
func GetConstInt(Key string) int {
	data, err := gamedata.GetDataByKey(CONST_NAME, Key)
	if err != nil {
		log.Debug("GetConst GetOne Id:%s not found", Key)
		return 0
	}
	return gamedata.ParseInt(data["Value"])
}

func GetExtraEmitId() map[string]struct{} {
	Value := GetConst("EmitId_Extra_Order")
	arr := strings.Split(Value, ",")
	var r = make(map[string]struct{})
	for _, v := range arr {
		r[v] = struct{}{}
	}
	return r
}

func GetChessBagMaxGrid() int {
	return GetConstInt("chess_bag_max")
}

func GetChessBagBugNum() int {
	return GetConstInt("chess_bag_buy")
}

func GetChessBagInitNum() int {
	return GetConstInt("chess_bag_init")
}

func GetSourceChestItem() []*item.Item {
	data, err := gamedata.GetDataByKey(CONST_NAME, "source_chest_reward")
	if err != nil {
		log.Debug("GetSourceChestItem GetOne not found")
		return nil
	}
	Str := gamedata.ParseString(data["Value"])
	A1 := strings.Split(Str, "|")
	var r []*item.Item
	if len(A1) < 2 {
		return r
	}
	A2 := strings.Split(A1[0], "/")
	A3 := GoUtil.StringToInt(A2)
	A4 := GoUtil.RandSlice(A3)
	r = append(r, item.NewItem(item.ITEM_DIAMOND_ID, A4))

	B2 := strings.Split(A1[1], "/")
	B3 := GoUtil.StringToInt(B2)
	B4 := GoUtil.RandSlice(B3)
	r = append(r, item.NewItem(item.ITEM_ENERGY_ID, B4))
	return r
}

func GetHighSourceChestItem() []*item.Item {
	data, err := gamedata.GetDataByKey(CONST_NAME, "high_source_chest_reward")
	if err != nil {
		log.Debug("GetHighSourceChestItem GetOne not found")
		return nil
	}
	Str := gamedata.ParseString(data["Value"])
	A1 := strings.Split(Str, "|")
	var r []*item.Item
	if len(A1) < 2 {
		return r
	}
	A2 := strings.Split(A1[0], "/")
	A3 := GoUtil.StringToInt(A2)
	A4 := GoUtil.RandSlice(A3)
	r = append(r, item.NewItem(item.ITEM_DIAMOND_ID, A4))

	B2 := strings.Split(A1[1], "/")
	B3 := GoUtil.StringToInt(B2)
	B4 := GoUtil.RandSlice(B3)
	r = append(r, item.NewItem(item.ITEM_ENERGY_ID, B4))
	return r
}

func DynamicLev(Lv int, EmitId int, Color string) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
	if err != nil {
		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
		return Lv
	}
	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
	if DynamicLv == "" {
		return Lv
	}
	Arr := strings.Split(DynamicLv, ",")
	for _, v := range Arr {
		Arr2 := strings.Split(v, "=")
		if len(Arr2) != 2 {
			continue
		}
		if Color == Arr2[0] {
			NewLv, _ := strconv.Atoi(Arr2[1])
			return Lv - NewLv
		}
	}
	return Lv
}
func DynamicLev2(Lv int, EmitId int, Color1 string, Color2 string) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
	if err != nil {
		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
		return Lv
	}
	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
	if DynamicLv == "" {
		return Lv
	}
	Arr := strings.Split(DynamicLv, ",")
	BaseLv := Lv
	for _, v := range Arr {
		Arr2 := strings.Split(v, "=")
		if len(Arr2) != 2 {
			continue
		}
		if Color1 == Arr2[0] {
			NewLv, _ := strconv.Atoi(Arr2[1])
			BaseLv = Lv + NewLv
		}
	}
	for _, v := range Arr {
		Arr2 := strings.Split(v, "=")
		if len(Arr2) != 2 {
			continue
		}
		if Color2 == Arr2[0] {
			NewLv, _ := strconv.Atoi(Arr2[1])
			return BaseLv - NewLv
		}
	}
	return Lv
}

func DynamicAdjust(EmitId int, Color string) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
	if err != nil {
		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
		return 0
	}
	DynamicLv := gamedata.GetStringValue(data, "Dynamic")
	if DynamicLv == "" {
		return 0
	}
	Arr := strings.Split(DynamicLv, ",")
	for _, v := range Arr {
		Arr2 := strings.Split(v, "=")
		if len(Arr2) != 2 {
			continue
		}
		if Color == Arr2[0] {
			NewLv, _ := strconv.Atoi(Arr2[1])
			return NewLv
		}
	}
	return 0
}

func GetAdjust(EmitId int, Color string) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
	if err != nil {
		log.Debug("DynamicLev GetOne EmitId:%v not found", EmitId)
		return 0
	}
	AdjustLv := gamedata.GetStringValue(data, "Dynamic")
	if AdjustLv == "" {
		return 0
	}
	Arr := strings.Split(AdjustLv, ",")
	for _, v := range Arr {
		Arr2 := strings.Split(v, "=")
		if len(Arr2) != 2 {
			continue
		}
		if Color == Arr2[0] {
			NewLv, _ := strconv.Atoi(Arr2[1])
			return NewLv
		}
	}
	return 0
}

func GetSellDiamondMul(EmitId int, Color string) int {
	data, err := gamedata.GetDataByIntKey(CFG_NAME, EmitId)
	if err != nil {
		log.Debug("GetSellDiamondMul GetOne EmitId:%v not found", EmitId)
		return 0
	}
	ProductEmit := gamedata.GetStringValue(data, "Emit_Product")
	if ProductEmit == "" {
		return 1
	}
	Arr := strings.Split(ProductEmit, ",")
	if Color == Arr[0] {
		return 1
	}
	if !GoUtil.InStringArray(Color, Arr) {
		return 1
	}
	Emit_List := gamedata.GetStringValue(data, "Emit_List")
	MainProb := getColorProb(Emit_List, Arr[0])
	SubProb := getColorProb(Emit_List, Color)
	return int(MainProb / SubProb)
}

func getColorProb(Emit_List string, Color string) float64 {
	Arr := strings.Split(Emit_List, ",")
	Prob := 0.0
	for _, v := range Arr {
		Arr2 := strings.Split(v, "=")
		A1 := GoUtil.Int(Arr2[0])
		A2, _ := strconv.ParseFloat(Arr2[1], 64)
		A1Color := GetColorById(A1)
		if A1Color != Color {
			continue
		}
		Prob += A2 * float64(A1%10)
	}
	return Prob
}

func GetColorType(Color string) int {
	data, err := gamedata.GetDataByKey(CFG_MERGE_COLOR, Color)
	if err != nil {
		log.Debug("GetColorType GetOne Color:%s not found", Color)
		return 0
	}
	Type := gamedata.GetStringValue(data, "Type")
	switch Type {
	case "main":
		return CHESS_PRODUCT_MAIN_TYPE
	case "secondary":
		return CHESS_PRODUCT_SECONDARY_TYPE
	case "sub":
		return CHESS_PRODUCT_SUB_TYPE
	}
	return CHESS_PRODUCT_MAIN_TYPE
}

func GetMergeStar(MergeList []int) int {
	Star := 0
	for _, v := range MergeList {
		Star += GetStarById(v)
	}
	return Star
}

func GetAllChessBySeries(Series string) []int {
	data, err := gamedata.GetData(CFG_NAME)
	ProductList := GetEmitProduce(Series)
	if err != nil {
		return []int{}
	}
	var r []int
	for k, v := range data {
		Type := gamedata.GetStringValue(v, "Type")
		if Type == "Emitter" {
			EmitId := gamedata.GetStringValue(v, "Emit_ID")
			if EmitId == Series {
				r = append(r, GoUtil.Int(k))
			}
		}
		if Type == "Product" {
			Color := gamedata.GetStringValue(v, "Color")
			if GoUtil.InStringArray(Color, ProductList) {
				r = append(r, GoUtil.Int(k))
			}
		}
	}
	return r
}